C# 4 and .NET 4

108 ❘ ChaPTer 5 Generics
The following sections explore the advantages and disadvantages of generics, particularly in regard to:
➤
➤
➤
➤
➤
Pe r f o r m a n c e
Type safety
Binary code reuse
Code bloat
Performance
Naming guidelines
One of the big advantages of generics is performance. In Chapter 10, “ Collections, ” you will see non - generic
and generic collection classes from the namespaces System.Collections and System.Collections.
Generic . Using value types with non - generic collection classes results in boxing and unboxing when the
value type is converted to a reference type and vice versa.
Boxing and unboxing is discussed in Chapter 7, “ Operators and Casts. ” Here is just a
short refresher about these terms.
Value types are stored on the stack. Reference types are stored on the heap. C# classes are reference types;
structs are value types. .NET makes it easy to convert value types to reference types, so you can use a
value type everywhere an object (which is a reference type) is needed. For example, an int can be assigned
to an object. The conversion from a value type to a reference type is known as boxing . Boxing happens
automatically if a method requires an object as a parameter, and a value type is passed. On the other side, a
boxed value type can be converted to a value type by using unboxing. With unboxing, the cast operator
is required.
The following example shows the ArrayList class from the namespace System.Collections . ArrayList
stores objects; the Add() method is defi ned to require an object as a parameter, and so an integer type is
boxed. When the values from an ArrayList are read, unboxing occurs when the object is converted to
an integer type. This may be obvious with the cast operator that is used to assign the fi rst element of the
ArrayList collection to the variable i1 , but also happens inside the foreach statement where the variable
i2 of type int is accessed:
var list = new ArrayList();
list.Add(44); // boxing — convert a value type to a reference type
int i1 = (int)list[0]; // unboxing — convert a reference type to
// a value type
foreach (int i2 in list)
{
Console.WriteLine(i2); // unboxing
}
Boxing and unboxing are easy to use but have a big performance impact, especially when iterating through
many items.
Instead of using objects, the List < T > class from the namespace System.Collections.Generic allows you
to defi ne the type when it is used. In the example here, the generic type of the List < T > class is defi ned as
int , so the int type is used inside the class that is generated dynamically from the JIT compiler. Boxing and
unboxing no longer happens:
var list = new List < int > ();
list.Add(44); // no boxing — value types are stored in the List < int >
int i1 = list[0]; // no unboxing, no cast needed
www.it-ebooks.info