CHAPTER 19 GENERICS

Constraints on Type Parameters

In the generic stack example, the stack did not do anything with the items it contained other than store them and pop them. It didn’t try to add them, compare them, or do anything else that would require using operations of the items themselves. There’s good reason for that. Since the generic stack doesn’t know the type of the items it will be storing, it can’t know what members these types implement.

All C# objects, however, are ultimately derived from class object, so the one thing the stack can be sure of about the items it’s storing is that they implement the members of class object. These include methods ToString, Equals, and GetType. Other than that, it can’t know what members are available.

As long as your code doesn’t access the objects of the types it handles (or as long as it sticks to the members of type object), your generic class can handle any type. Type parameters that meet this constraint are called unbounded type parameters. If, however, your code tries to use any other members, the compiler will produce an error message.

For example, the following code declares a class called Simple with a method called LessThan that takes two variables of the same generic type. LessThan attempts to return the result of using the less-than operator. But not all classes implement the less-than operator, so you can’t just substitute any class for T. The compiler, therefore, produces an error message.

To make generics more useful, therefore, you need to be able to supply additional information to the compiler about what kinds of types are acceptable as arguments. These additional bits of information are called constraints. Only types that meet the constraints can be substituted for the given type parameter.

478

CHAPTER 19 GENERICS

Where Clauses

Constraints are listed as where clauses.

•Each type parameter that has constraints has its own where clause.

•If a parameter has multiple constraints, they are listed in the where clause, separated by commas.

The syntax of a where clause is the following:

where TypeParam : constraint, constraint, ...

The important points about where clauses are the following:

•They’re listed after the closing angle bracket of the type parameter list.

•They’re not separated by commas or any other token.

•They can be listed in any order.

•The token where is a contextual keyword, so you can use it in other contexts.

For example, the following generic class has three type parameters. T1 is unbounded. For T2, only classes of type Customer, or classes derived from Customer, can be used as type arguments. For T3, only classes that implement interface IComparable can be used as type arguments.

}

479

CHAPTER 19 GENERICS

Constraint Types and Order

There are five types of constraints. These are listed in Table 19-2.

Table 19-2. Types of Constraints

The where clauses can be listed in any order. The constraints in a where clause, however, must be placed in a particular order, as shown in Figure 19-9.

•There can be at most one primary constraint, and if there is one, it must be listed first.

•There can be any number of InterfaceName constraints.

•If the constructor constraint is present, it must be listed last.

Figure 19-9. If a type parameter has multiple constraints, they must be in this order.

The following declarations show examples of where clauses:

class SortedList<S>

where S: IComparable<S> { ... }

class MyDictionary<KeyType, ValueType>

480