Generics
Generics within C# give us the ability to create classes that provide functionality in a generic way. This means we can take a class that has some underlying type and implement it so that all types can be used by the container class. System.Collections.Generics provides some great examples of generics with their List and Dictionary implementations.
example:
System.Collections.Generics.List<string> types = new System.Collections.Generics.List<string>();
AND
System.Collections.Generics.List<Rect> types = new System.Collections.Generics.List<Rect>();
The implementation of List is standard but the template argument can be any available type. We can also have generic functions, where the function defines a template and uses the generic type as either arguments or in the function.
Extension Methods
Extension methods provide nice flexibility to extend existing class within .NET. They allow us to add functions to classes that we can call on the object like it is an actual method on the class itself.
example:
public static partial class Tools
{
public static string ToBase64(this string s)
{
return System.Convert.ToBase64String( System.Text.Encoding.Unicode.GetBytes(s) );
}
}
And we can call this function like it is part of the string class.
string s = "base64";
string b64 = s.ToBase64();
The key parts to creating extension methods are they need to be in a static class and the first parameter has the "this" keyword which will apply the method to the given class.
Generic Extension Methods
So now onto the topic: Generic Extension Methods. What this means is creating an extension method from a generic function template. So you now are probably asking "WHY?" or "When would I use this?" Both are great questions, so I've got a great example.
I tend to be pattern oriented. I use patterns constantly throughout my code. One pattern is setting a property value and notifying listeners that the property has changed. Instead of writing the same code over and over which checks the equality, then calls the handler if the value did-in-fact change. Using a generic extension method is perfect for this use case.
My code:
public static partial class Extensions
{
public static bool SetAndNotify<T>(this T newValue, ref T oldValue, object sender, string propertyName, System.ComponentModel.PropertyChangedEventHandler handler)
{
if (newValue==null && oldValue==null) return false;
if (newValue.Equals(oldValue)) return false;
oldValue = newValue;
if (handler!=null)
handler(sender, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
return true;
}
}
And to use it:
...
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
private SomeType _MyProperty = null;
public SomeType MyProperty
{
get { return _MyProperty; }
set { value.SetAndNotify<SomeType>(ref _MyProperty, this, "MyProperty", PropertyChanged); }
}
...
As you can see, anytime I need to notify when a property is changed, I can just use the above code over and over. It's important to note that with this code, I pass the reference of the member variable. This allows me to change the value. And there you have it, a Generic Extension Method.
It should also be noted... This code is only checking for nulls. we should probably also check for default(T) in the instance where T is a struct, but I don't have time to try it...
UPDATE: You can also call the SetAndNotify without explicitly declaring the template, but I like to be explicit.
[Insert explicitive here]
Subscribe