Back when I was primarily
a C++ developer, I loved C++ templates. The power of writing very reusable generic classes brought the art of programming to
a brand new level. Unfortunately, when .NET 1.0 came about, they didn’t have
a template equivalent. With .NET 2.0 however, we finally got generics, which once again let us spread our wings and program more generically in the world of .NET However, C# generics behave in some ways very differently from their C++ template cousins. There is
a handy clause, however, that helps you navigate these waters to make your generics more powerful. The Problem – C# Assumes Lowest Common Denominator In C++, you can create
a template and do nearly anything syntactically possible on the template parameter, and C++ will not check if the method/fields/operations invoked are valid until you declare
a realization of the
type. Let me illustrate with
a C++ example: 1: // compiles fine, C++ makes no assumptions as to T
2: template <typename T>
3: class ReverseComparer
4: {
5: public:
6: int Compare(const T& lhs, const T& rhs)
7: {
8: return rhs.CompareTo(lhs);
9: }
10: };
Notice that we are invoking
a method CompareTo() off of template
type T. Because we don’t know at this point what
type T is, C++ makes no assumptions and there are no errors.
C++ tends to take the path of not checking the template
type usage until the method is actually invoked with
a specific
type, which differs from the behavior of C#:
1: // this will NOT compile! C# assumes lowest common denominator.
2: public class ReverseComparer<T>
3: {
4: public int Compare(T lhs, T rhs)
5: {
6: return lhs.CompareTo(rhs);
7: }
8: }
So why does C# give us
a compiler error even when we don’t yet know what
type T is? This is because C# took
a different path in how they made generics. Unless you specify otherwise, for the purposes of the code inside the generic method, T is basically treated like an object (notice I didn’t say T is an object).
That means that any operations, fields, methods, properties, etc that you attempt to use of
type T must be available at the lowest common denominator type: object.
Now, while object has the broadest applicability, it also has the fewest specific. So how do we allow our generic
type placeholder to do things more than just what object can do?
Solution: Constraint the
Type With Where Clause
So how do we get around this in C#? The answer is to constrain the generic
type placeholder with the where clause. Basically, the where clause allows you to specify additional constraints on what the actual
type used to fill the generic
type placeholder must support.
You might think that narrowing the scope of
a generic means
a weaker generic. In reality, though it limits the number of types that can be used with the generic, it also gives the generic more power to deal with those types. In effect these constraints says that if the
type meets the given constraint, you can perform the activities that pertain to that constraint with the generic placeholders.
Constraining Generic
Type to Interface or Superclass
One of the handiest where clause constraints is the ability to specify the
type generic
type must implement
a certain interface or be inherited from
a certain base class.
For example, you can’t call CompareTo() in our first C# generic without constraints, but if we constrain T to IComparable<T>, we can:
1: public class ReverseComparer<T>
2: where T : IComparable<T>
3: {
4: public int Compare(T lhs, T rhs)
5: {
6: return lhs.CompareTo(rhs);
7: }
8: }
Now that we’ve constrained T to an implementation of IComparable<T>, this means that our variables of generic
type T may now call any members specified in IComparable<T> as well. This means that the call to CompareTo() is now legal.
If you constrain your
type, also, you will get compiler warnings if you attempt to use
a type that doesn’t meet the constraint. This is much better than the syntax error you would get within C++ template code itself when you used
a type not supported by
a C++ template.
Constraining Generic
Type to Only Reference Types
Sometimes, you want to assign an instance of
a generic
type to null, but you can’t do this without constraints, because you have no guarantee that the
type used to realize the generic is not
a value
type, where null is meaningless.
Well, we can fix this by specifying the class constraint in the where clause. By declaring that
a generic
type must be
a class, we are saying that it is
a reference
type, and this allows us to assign null to instances of that type:
1: public static class ObjectExtensions
2: {
3: public static TOut Maybe<TIn, TOut>(this TIn value, Func<TIn, TOut> accessor)
4: where TOut : class
5: where TIn : class
6: {
7: return (value != null) ? accessor(value) : null;
8: }
9: }
In the example above, we want to be able to access
a property off of
a reference, and if that reference is null, pass the null on down the line. To do this, both the input
type and the output
type must be reference types (yes, nullable value types could also be considered applicable at
a logical level, but there’s not
a direct constraint for those).
Constraining Generic
Type to only Value Types
Similarly to constraining
a generic
type to be
a reference
type, you can also constrain
a generic
type to be
a value
type. To do this you use the struct constraint which specifies that the generic
type must be
a value
type (primitive, struct, enum, etc).
Consider the following method, that will convert anything that is IConvertible (int, double, string, etc) to the value
type you specify, or null if the instance is null.
1: public static T? ConvertToNullable<T>(IConvertible value)
2: where T : struct
3: {
4: T? result = null;
5:
6: if (value != null)
7: {
8: result = (T)Convert.ChangeType(value, typeof(T));
9: }
10:
11: return result;
12: }
Because T was constrained to be
a value
type, we can use T? (System.Nullable<T>) where we could not do this if T was
a reference
type.
Constraining Generic
Type to Require Default Constructor
You can also constrain
a type to require existence of
a default constructor. Because by default C# doesn’t know what constructors
a generic
type placeholder does or does not have available, it can’t typically allow you to call one. That said, if you give it the new() constraint, it will mean that the
type used to realize the generic
type must have
a default (no argument) constructor.
Let’s assume you have
a generic adapter class that, given some mappings, will adapt an item from
type TFrom to
type TTo. Because it must create
a new instance of
type TTo in the process, we need to specify that TTo has
a default constructor:
1: // Given
a set of Action<TFrom,TTo> mappings will map TFrom to TTo
2: public class Adapter<TFrom, TTo> : IEnumerable<Action<TFrom, TTo>>
3: where TTo : class, new()
4: {
5: // The list of translations from TFrom to TTo
6: public List<Action<TFrom, TTo>> Translations { get; private set; }
7:
8: // Construct with empty translation and reverse translation sets.
9: public Adapter()
10: {
11: // did this instead of auto-properties to allow simple use of initializers
12: Translations = new List<Action<TFrom, TTo>>();
13: }
14:
15: // Add
a translator to the collection, useful for initializer list
16: public void Add(Action<TFrom, TTo> translation)
17: {
18: Translations.Add(translation);
19: }
20:
21: // Add
a translator that first checks
a predicate to determine if the translation
22: // should be performed, then translates if the predicate returns true
23: public void Add(Predicate<TFrom> conditional, Action<TFrom, TTo> translation)
24: {
25: Translations.Add((from, to) =>
26: {
27: if (conditional(from))
28: {
29: translation(from, to);
30: }
31: });
32: }
33:
34: // Translates an object forward from TFrom object to TTo object.
35: public TTo Adapt(TFrom sourceObject)
36: {
37: var resultObject = new TTo();
38:
39: // Process each translation
40: Translations.ForEach(t => t(sourceObject, resultObject));
41:
42: return resultObject;
43: }
44:
45: // Returns an enumerator that iterates through the collection.
46: public IEnumerator<Action<TFrom, TTo>> GetEnumerator()
47: {
48: return Translations.GetEnumerator();
49: }
50:
51: // Returns an enumerator that iterates through
a collection.
52: IEnumerator IEnumerable.GetEnumerator()
53: {
54: return GetEnumerator();
55: }
56: }
Notice, however, you can’t specify any other constructor, you can only specify that the
type has
a default (no argument) constructor.
Summary
The where clause is an excellent tool that gives your .NET generics even more power to perform tasks higher than just the base "object level" behavior.
There are
a few things you cannot specify with constraints (currently) though:
Cannot specify the generic
type must be an enum.
Cannot specify the generic
type must have
a certain property or method without specifying
a base class or interface – that is, you can’t say that the generic must have
a Start() method.
Cannot specify that the generic
type allows arithmetic operations.
Cannot specify that the generic
type requires
a specific non-default constructor.
In addition, you cannot overload
a template definition with different, opposing constraints. For example you can’t define
a Adapter<T> where T : struct and Adapter<T> where T : class.
Hopefully, in the future we will get some of these things to make the where clause even more useful, but until then what we have is extremely valuable in making our generics more user friendly and more powerful!
Technorati Tags: C#,.NET,Little Wonders,BlackRabbitCoder,where,generics
