(How)
C^# You Are - 11 March 2007

This week's questions are on declaring and using generics.

What is a generic type? A type parameter? Answer

A generic type is a type with at least one type parameter. A generic type is not a concrete type and therefore can not be instantiated directly. A type parameter is a parameter to a generic type declaration that identifies what type the declaration will hold. When a generic type is combined with a type (for each type parameter) then it becomes a concrete type and can be instantiated.

public class MyCustomClass<T, K> { ...}

In the above declaration the generic type name is MyCustomClass. The generic type parameters are T and K. Until both type parameters are assigned types the class can not be instantiated.
How do you restrict a generic type parameter to be an enumeration? A structure? Answer

To restrict a generic type parameter to a specific type, subset of types or feature you use a constraint. Each type parameter can have zero or more constraints. A constraint is defined by appending the where clause and specifying the constraint(s). For example

public class MyCustomClass<T, K> where T : class { ...}

limits T to being a reference type. K can be any type.

You can not limit a type parameter to a specific enumeration or even an enumeration in general. Nor can you limit the type parameter to a specific structure. Instead you can limit the type parameter to a value type by using struct. If you think about it for a second it makes sense. Value types can not derive from other types (beyond the basic hierarchy defined by the CLR). Therefore if you constrained a type parameter to a specific value type then only that value type would ever be valid anyway. For example

public struct MyStructData { ... }

public class MyCustomClass<T, K> where T : MyStructData { ...}

T would have to be either of type MyStructData or a type deriving from MyStructData. Since MyStructData is a structure it can not have derived types so only MyStructData would work. Since there is only one type that would work there is really no benefit in using a generic type.
How do you declare a generic type member as static? Answer

Just like you would for a regular type, use the static keyword on the member like so.

public class MyList<T>
{
   public static int m_Count = 0;
   public static int Count
   { get { return ++m_Count; } }
}

In the above class each time the static propert Count is called it is incremented by one. Now if we execute the following code we'll get the results displayed in the comments.

class Program
{
   static void Main ( string[] args )
   {
Console.WriteLine(MyList<int>.Count); // 1
Console.WriteLine(MyList<string>.Count); // 1
Console.WriteLine(MyList<float>.Count); // 1
Console.WriteLine(MyList<string>.Count); // 2
Console.WriteLine(MyList<StringBuilder>.Count); // 1
   }
}

What is happening? In .NET static members are created for each unique, concrete type created when the generic type parameters are associated with a type. In the above example only one case reused and existing type and therefore in only one case was the static field incremented to 2.

As a lesson, be leary of using static members in generic types unless you are comfortable with how they will work with differing types.
How do you refer to null within a generic type member? Answer

You simply refer to null like so. In this example we do not allow null items to be inserted.

public class MyList<T>
{
   public void Add ( T item )
   {
if (item == null)
   throw new ArgumentNullException("item");

...
   }
}

But there is a problem. How will value types react to this? The answer is that the if statement, when the type parameter is a value type, will never be false. This might or might not be a good thing. In general we use null to refer to the initial, or unassigned, state of an object. For value types there is no such concept. Still it would be useful to know, or use, the default value of a type.

We can mimic this initial state for all types, reference or value, by using the default expression. This expression takes a type and evaluates to the appropriate default value. For reference types it will be null. For value types it will normally be 0. We can change our generic method to use the default expression and now we can detect whenever a value is passed to the method that is the default value for the type.

public class MyList<T>
{
   public void Add ( T item )
   {
if (item.Equals(default(T)))
   throw new ArgumentNullException("item");

...
   }
}

Notice the use of Equals because == will no longer work.
How do you create a new instance of a generic type parameter within a generic type member? Answer

This is easy, just use new like you normally would, like so.

public class Creator<T>
{
   public T Create ( )
   {
return new T();
   }
}

Oops. It won't compile. The problem is that we're assuming that there is a default constructor defined for the type and there might not be. If we really need to create an instance of the type inside the generic type then we will need to add a constraint telling the compiler that we must have a default constructor available.

public class Creator<T> where T : new()
{
   public T Create ( )
   {
return new T();
   }
}

Just to go full circle notice that there is no constraint you can define that allows you to require any constructors other than a default constructor. If you need to be able to pass data to the newly created instance you will either need to use properties or methods which will then mandate a constraint for an interface or base type.
How do you declare a generic interface? Answer

You declare a generic interface just like you do a generic class.

public interface ICreatableObject<T>
{
T CreateInstance ( );
}
Given the following code, what should XYZ be? Answer

public class DataObject<T>
{
   public abstract void PrintInformation ( );
}

public class PersonObject : DataObject<Person> { ... }
public class JobObject : DataObject<Job> { ... }

public class DebugInformation
{
   public void PrintInformation ( XYZ data )
   {
data.PrintInformation();
   }
}

There is no type that you can specify that will get this to work. It is a common misconception that inheritance and generic types are somehow related. They aren't. Two concrete types built from the same generic type but with different type parameters are no more related than a string and an integer. Inheritance is based off the generic type itself. Therefore if you want to be able to pass differing versions of a generic type to methods you must either create a base class from which the generic type derives and which contains no generic type parameters or an interface.

In .NET generic interfaces almost always derive from a non-generic interface with equivalent functionality. Generic types generally implement generic interfaces, and by definition, the non-generic base interface as well. Here is how you can modify the above code to compile.

public abstract BaseDataObject
{
   public abstract void PrintInformation ( );
   public abstract object Data { get; }
}

public class DataObject<T> : BaseDataObject
{
}

public class PersonObject : DataObject<Person> { ... }
public class JobObject : DataObject<Job> { ... }

public class DebugInformation
{
   public void PrintInformation ( BaseDataObject data )
   {
data.PrintInformation();
   }
}

Not quite as clean as we would like. An interface would do better here.

public interface IDataObject
{
   void PrintInformation ( );
   object Data { get; }
}

public interface IDataObject<T> : IDataObject
{
   T Data { get; }
}

public class DataObject<T> : IDataObject<T>
{
   abstract T Data { get; }

   object IDataObject.Data
   { get { return this.Data; } }
}

public class PersonObject : DataObject<Person> { ... }
public class JobObject : DataObject<Job> { ... }

public class DebugInformation
{
   public void PrintInformation ( IDataObject data )
   {
data.PrintInformation();
   }
}

Finally, as an alternative we could make the original PrintInformation method generic and then use the generic interface we originally wrote.

public class DataObject<T>
{
   public abstract void PrintInformation ( );
}

public class PersonObject : DataObject<Person> { ... }
public class JobObject : DataObject<Job> { ... }

public class DebugInformation
{
   public void PrintInformation<T> (DataObject<T> data )
   {
data.PrintInformation();
   }
}

(Updated 24 Mar 2007 w/ alternative received from James Curran)
Generics are commonly considered to be equivalent to C++ templates but this is wrong. Why? Answer

C++ templates are true cookie cutters in code. Each time a template is used for a new type a complete copy of the code is created to back it. This happens at compile time. Therefore at compile time the template code is needed. This results in code bloat. Templates in C++ are really useful for generating the same code for different types almost like a code generator. Although they are traditionally thought of as being reusable code that is applied to differing types in actuality this is the compiler doing the cut and paste for you. Definitely makes things easier but compiling and debugging templates is difficult and results in code bloat.

Generics on the other hand are truly reusing the same code for the different types. In .NET a generic type is compiled into an assembly just like any other type. At runtime when a generic type is combined with a type parameter(s) and instantiated the CLR looks to see if the underlying concrete type has been created yet. If it has then it is reused (cutting down on code bloat) otherwise a new concrete type is created. Reference types all use the same concrete type. During creation of the generic type all references to the type parameter are "converted" to object. When referencing a generic type the compiler has all the type information needed to ensure that the constraints are met and to convert to and from the appropriate type for the type parameter. Therefore object can be used safely.

For value types a new instance is created for each value type. This is because value types can differ in size and therefore can not share the same underlying implementation. However remember that this is a runtime thing so the assembly containing the generic type definition still only has a single copy of the generic type and assemblies that reference the generic type still only reference the generic type itself and not the underlying concrete type. The concrete type is created as needed by the CLR. This reduces coat bloat while still allowing generics to work properly.
How do you create an instance of a generic type at runtime when you do not know the type parameter in advance? Answer

Although this sounds like a rare situation (it certainly isn't common) it does come up enough to warranty a solution. Here are the steps.

//Get the generic type definition, you can do this a variety of ways - notice the formal type name syntax for generic types
Type typeGeneric = Type.GetType("System.Collections.Generic.List`1");

//Assign types to each type parameter in order to form a concrete type
Type typeConcrete = typeGeneric.MakeGenericType(typeof(string));

//Create an instance of the type
object obj = Activator.CreateInstance(typeConcrete); //Type is List<string>
How do you retrieve the generic type information about a class at runtime? Answer

The Type class exposes properties that tell you whether a type is a generic type and, if so, what the value of the type parameters are. When IsGenericType and IsGenericTypeDefinition are true then the type is a generic type (not a concrete type). If IsGenericType is true and IsGenericTypeDefinition is false then the type is a concrete type created from a generic type. The somewhat related IsGenericParameter property is set to true when referencing a type parameter of a generic type. For the generic type itself it will be false.

//IsGenericType=true; IsGenericTypeDefinition=true;
Type typeGeneric = Type.GetType("System.Collections.Generic.List`1");

//IsGenericType=true; IsGenericTypeDefinition=false;
Type typeConcrete = typeGeneric.MakeGenericType(typeof(string));

object obj = Activator.CreateInstance(typeConcrete);

Given a generic type definition you can retrieve the generic type parameters using the GetGenericArguments method.

Type typeGeneric = Type.GetType("System.Collections.Generic.List`1");

//Gets the generic type parameters
Type[] typeParms = typeGeneric.GetGenericArguments();

Given a concrete type that was produced by a generic type definition you can retrieve the underlying type definition along with the values used for the type parameters.

Type typeGeneric = Type.GetType("System.Collections.Generic.List`1");
Type typeConcrete = typeGeneric.MakeGenericType(typeof(string));
object obj = Activator.CreateInstance(typeConcrete);

//Get the concrete type from which the object was created
Type typeObj = obj.GetType();

//Get the type parameters used to create the concrete type (better be sure it was generated from a generic type)
Type[] typesObjParms = typeObj.GetGenericArguments();

(How) C^# You Are - 11 March 2007

(How)
C^# You Are - 11 March 2007