C# 4 and .NET 4

Generics overview ❘ 109
foreach (int i2 in list)
{
Console.WriteLine(i2);
}
Type safety
Another feature of generics is type safety. As with the ArrayList class, if objects are used, any type can be
added to this collection. This example shows adding an integer, a string, and an object of type MyClass to
the collection of type ArrayList:
var list = new ArrayList();
list.Add(44);
list.Add("mystring");
list.Add(new MyClass());
Now if this collection is iterated using the following foreach statement, which iterates using integer
elements, the compiler accepts this code. However, because not all elements in the collection can be cast to
an int, a runtime exception will occur:
foreach (int i in list)
{
Console.WriteLine(i);
}
Errors should be detected as early as possible. With the generic class List, the generic type T defines
what types are allowed. With a definition of List, only integer types can be added to the collection.
The compiler doesn’t compile this code because the Add() method has invalid arguments:
var list = new List();
list.Add(44);
list.Add("mystring"); // compile time error
list.Add(new MyClass()); // compile time error
binary Code reuse
Generics allow better binary code reuse. A generic class can be defined once and can be instantiated with
many different types. Unlike C++ templates, it is not necessary to access the source code.
As an example, here the List class from the namespace System.Collections.Generic is instantiated
with an int, a string, and a MyClass type:
var list = new List();
list.Add(44);
var stringList = new List();
stringList.Add("mystring");
var myClassList = new List();
myClassList.Add(new MyClass());
Generic types can be defined in one language and used from any other .NET language.
Code bloat
How much code is created with generics when instantiating them with different specific types
Because a generic class definition goes into the assembly, instantiating generic classes with specific types
doesn’t duplicate these classes in the IL code. However, when the generic classes are compiled by the JIT
compiler to native code, a new class for every specific value type is created. Reference types share all the
same implementation of the same native class. This is because with reference types, only a 4-byte memory
address (with 32-bit systems) is needed within the generic instantiated class to reference a reference type.
www.it-ebooks.info