34manipulate. This feature is really a set of features known collectively as generics. C# generics will

Chapter 8 Language overview

1object, into a Customer type, which is tedious to write, and carries a performance penalty for run-time

2type checking:

3Stack s = new Stack();

4s.Push(new Customer());

5Customer c = (Customer)s.Pop();

6If we pass to the Push method a value type, such as an int, it will automatically be boxed. Similarly, if we

7want to retrieve an int from the stack, we would need to explicitly unbox the object type we obtain from

8the Pop method:

9Stack s = new Stack();

10s.Push(3);

11int i = (int)s.Pop();

12Such boxing and unboxing operations can impact performance.

13Furthermore, in the implementation shown, it is not possible to enforce the kind of data placed in the stack.

14Indeed, we could create a stack and push a Customer type onto it. However, later, we could use the same

15stack and try to pop data off of it and cast it into an incompatible type:

16Stack s = new Stack();

17s.Push(new Customer());

18Employee e = (Employee)s.Pop(); // runtime error

19While the code above is an improper use of the Stack class we presumably intended to implement, and

20should be a compile-time error, it is actually valid code. However, at run-time, the application will fail

21because we have performed an invalid cast operation.

228.16.2 Creating and consuming generics

23Generics provide a facility for creating high-performance data structures that are specialized by the compiler

24and/or execution engine based on the types that they use. These so-called generic type declarations are

25created so that their internal algorithms remain the same, yet the types of their external interface and internal

26data can vary based on user preference.

27In order to minimize the learning curve for developers, generics are used in much the same way as C++

28templates. Programmers can create classes and structures just as they normally have, and by using the angle

29bracket notation (< and >) they can specify type parameters. When the generic class declaration is used, each

30type parameter shall be replaced by a type argument that the user of the class supplies.

31In the example below, we create a Stack generic class declaration where we specify a type parameter,

32called ItemType, declared in angle brackets after the declaration. Rather than forcing conversions to and

33from object, instances of the generic Stack class will accept the type for which they are created and store

34data of that type without conversion. The type parameter ItemType acts as a placeholder until an actual

35type is specified at use. Note that ItemType is used as the element type for the internal items array, the type

36for the parameter to the Push method, and the return type for the Pop method:

37public class Stack<ItemType>

38{

41public ItemType Pop() {…}

42}

43When we use the generic class declaration Stack, as in the short example below, we can specify the actual

44type to be used by the generic class. In this case, we instruct the Stack to use an int type by specifying it

45as a type argument using the angle brackets after the name:

46Stack<int> s = new Stack<int>();

47s.Push(3);

48int x = s.Pop();

49In so doing, we have created a new constructed type, Stack<int>, for which every ItemType inside the

50declaration of Stack is replaced with the supplied type argument int. Indeed, when we create our new

51instance of Stack<int>, the native storage of the items array is now an int[] rather than object[],

53

Chapter 8 Language overview

1public class Dictionary<KeyType, ElementType>

2{

8}

9}

10However, if we now construct a type from Dictionary and supply a type argument which does not

11implement IComparable, we will encounter a run-time error, specifically an InvalidCastException.

12Since one of the objectives of generics is to provide strong typing and to reduce the need for casts, a more

13elegant solution is needed.

14We can supply an optional list of constraints for each type parameter. A constraint indicates a requirement

15that a type shall fulfill in order to be accepted as a type argument. (For example, it might have to implement

16a given interface or be derived from a given base class.) A constraint is declared using the word where,

17followed by a type parameter and colon (:), followed by a comma-separated list of constraints, which can

18include a class type, interface types, other type parameters, the reference type constraint “class”, the value

19type constraint “struct”, and the constructor constraint “new()”.

20In order to satisfy our need to use the CompareTo method inside Dictionary, we can impose a constraint

21on KeyType, requiring any type passed as the first argument to Dictionary to implement IComparable,

22like so:

23public class Dictionary<KeyType, ElementType> where KeyType: IComparable

24{

30}

31}

32When compiled, this code will now be checked to ensure that each time we construct a Dictionary type

33we are passing a first type argument that implements IComparable. Further, we no longer have to

34explicitly cast variable key to IComparable before calling the CompareTo method.

35Constraints are most useful when they are used in the context of defining a framework, i.e. a collection of

36related classes, where it is advantageous to ensure that a number of types support some common signatures

37and/or base types. Constraints can be used to help define “generic algorithms” that plug together

38functionality provided by different types. This can also be achieved by subclassing and runtime

39polymorphism, but static, constrained polymorphism can, in many cases, result in more efficient code, more

40flexible specifications of generic algorithms, and more errors being caught at compile-time rather than run-

41time. However, constraints need to be used with care and taste. Types that do not implement the constraints

42will not easily be usable in conjunction with generic code.

43For any given type parameter, we can specify any number of interfaces and type parameters as constraints,

44but no more than one class. Each constrained type parameter has a separate where clause. In the example

45below, the KeyType type parameter has two interface constraints, while the ElementType type parameter

46has one class constraint:

47public class Dictionary<KeyType, ElementType >

49where ElementType: Customer

50{

55