Addison Essential Csharp_5 doc

Listing 11.24: Specifying the Type Parameter As a Value Type public struct Nullable : Because a base class constraint requires a particular base class, using struct or class with a base

implement the IComparable<T> interface The syntax for this appears in

Listing 11.22

Listing 11.22: Declaring an Interface Constraint

public class BinaryTree<T>

Given the interface constraint addition in Listing 11.22, the compiler

ensures that each time you use the BinaryTree class you specify a type

parameter that implements the IComparable<T> interface Furthermore,

you no longer need to explicitly cast the variable to an IComparable<T>

interface before calling the CompareTo() method Casting is not even

required to access members that use explicit interface implementation,

which in other contexts would hide the member without a cast To resolve

what member to call, the compiler first checks class members directly, and

then looks at the explicit interface members If no constraint resolves the

argument, only members of object are allowable

where T: System.IComparable<T>

// Notice that the cast can now be eliminated.

first = value.First.Item;

if (first.CompareTo(value.Second.Item) < 0)

Chapter 11: Generics

444

If you tried to create a BinaryTree<T> variable using System

Text.StringBuilder as the type parameter, you would receive a compiler

error because StringBuilder does not implement IComparable<T> The

error is similar to the one shown in Output 11.3

To specify an interface for the constraint you declare an interface

con-straint. This constraint even circumvents the need to cast in order to call an

explicit interface member implementation

Base Class Constraints

Sometimes you might want to limit the constructed type to a particular

class derivation You do this using a base class constraint, as shown in

Listing 11.23

Listing 11.23: Declaring a Base Class Constraint

public class EntityDictionary<TKey, TValue>

In contrast to System.Collections.Generic.Dictionary<TKey, TValue>

on its own, EntityDictionary<TKey, TValue> requires that all TValue

types derive from the EntityBase class By requiring the derivation, it is

possible to always perform a cast operation within the generic

implemen-tation, because the constraint will ensure that all type parameters derive

from the base and, therefore, that all TValue type parameters used with

EntityDictionary can be implicitly converted to the base

The syntax for the base class constraint is the same as that for the

inter-face constraint, except that base class constraints must appear first when

multiple constraints are specified However, unlike interface constraints,

O UTPUT 11.3:

error CS0309: The type ’System.Text.StringBuilder’ must be convertible

to ’System.IComparable<T>’ in order to use it as parameter ’T’ in the

generic type or method ’BinaryTree<T>’

multiple base class constraints are not allowed since it is not possible to

derive from multiple classes Similarly, base class constraints cannot be

specified for sealed classes or specific structs For example, C# does not

allow a constraint for a type parameter to be derived from string or

Sys-tem.Nullable<T>

struct/class Constraints

Another valuable generic constraint is the ability to restrict type

parame-ters to a value type or a reference type The compiler does not allow

speci-fying System.ValueType as the base class in a constraint Instead, C#

provides special syntax that works for reference types as well Instead of

specifying a class from which T must derive, you simply use the keyword

struct or class, as shown in Listing 11.24

Listing 11.24: Specifying the Type Parameter As a Value Type

public struct Nullable<T> :

Because a base class constraint requires a particular base class, using

struct or class with a base class constraint would be pointless, and in fact

could allow for conflicting constraints Therefore, you cannot use struct

and class constraints with a base class constraint

There is one special characteristic for the struct constraint It limits

possi-ble type parameters as being only value types while at the same time

prevent-ing type parameters that are System.Nullable<T> type parameters Why?

Without this last restriction, it would be possible to define the nonsense type

Nullable<Nullable<T>>, which is nonsense because Nullable<T> on its own

allows a value type variable that supports nulls, so a nullable-nullable type

becomes meaningless Since the nullable operator (?) is a C# shortcut for

declaring a nullable value type, the Nullable<T> restriction provided by the

struct constraint also prevents code such as the following:

int?? number // Equivalent to Nullable<Nullable<int> if allowed

where T : struct

Chapter 11: Generics

446

Multiple Constraints

For any given type parameter, you may specify any number of interfaces

as constraints, but no more than one class, just as a class may implement

any number of interfaces but inherit from only one other class Each new

constraint is declared in a comma-delimited list following the generic type

and a colon If there is more than one type parameter, each must be

pre-ceded by the where keyword In Listing 11.25, the EntityDictionary class

contains two type parameters: TKey and TValue The TKey type parameter

has two interface constraints, and the TValue type parameter has one base

class constraint

Listing 11.25: Specifying Multiple Constraints

public class EntityDictionary<TKey, TValue>

: Dictionary<TKey, TValue>

where TKey : IComparable<TKey>, IFormattable

where TValue : EntityBase

{

}

In this case, there are multiple constraints on TKey itself and an additional

constraint on TValue When specifying multiple constraints on one type

parameter, an AND relationship is assumed TKey must implement

ICom-parable<TKey> and IFormattable, for example

Notice there is no comma between each where clause

Constructor Constraints

In some cases, it is desirable to create an instance of a type parameter

inside the generic class In Listing 11.26, the New() method for the

EntityDictionary<TKey, TValue> class must create an instance of the

type parameter TValue

Listing 11.26: Requiring a Default Constructor Constraint

public class EntityBase<TKey>

{

public TKey Key

{

get{ return _Key; }

set{ _Key = value; }

}

Because not all objects are guaranteed to have public default constructors,

the compiler does not allow you to call the default constructor on the type

parameter To override this compiler restriction, you add the text new() after

all other constraints are specified This text is a constructor constraint, and it

forces the type parameter decorated with the constructor constraint to have

a default constructor Only the default constructor constraint is available

You cannot specify a constraint for a constructor with parameters

Constraint Inheritance

Constraints are inherited by a derived class, but they must be specified

explicitly on the derived class Consider Listing 11.27

Listing 11.27: Inherited Constraints Specified Explicitly

class EntityBase<T> where T : IComparable<T>

{

//

}

// ERROR:

// The type 'T' must be convertible to 'System.IComparable<T>'

// in order to use it as parameter 'T' in the generic type or

// method

where TValue : EntityBase<TKey>, new()

TValue newEntity = new TValue();

Because EntityBase requires that T implement IComparable<T>, the

Entity class needs to explicitly include the same constraint Failure to do

so will result in a compile error This increases a programmer’s awareness

of the constraint in the derived class, avoiding confusion when using the

derived class and discovering the constraint but not understanding where

it comes from

In contrast, constraints on generic override (or explicit interface)

meth-ods are inherited implicitly and may not be restated (see Listing 11.28)

Listing 11.28: Inherited Constraints Specified Explicitly

class EntityBase<T> where T : IComparable<T>

public virtual void Method<T>(T t)

// Error: Constraints may not be

// repeated on overriding members

In the inheritance case the type parameter on the base class can be

addi-tionally constrained by adding not only the constraints on the base class

(required), but also additional constraints as well However, overriding

members need to conform to the “interface” defined in the base class

method Additional constraints could break polymorphism, so they are

not allowed and the type parameter constraints on the override method

are implied

A D V A N C E D T O P I C

Constraint Limitations

Constraints are appropriately limited to avoid nonsense code For

exam-ple, you cannot combine a base class constraint with a struct or class

con-straint, nor can you use Nullable<T> on struct constraint type parameters

Also, you cannot specify constraints to restrict inheritance to special types

such as object, arrays, System.ValueType, System.Enum (enum),

Sys-tem.Delegate, and System.MulticastDelegate

In some cases, constraint limitations are perhaps more desirable, but

they still are not supported The following subsections provide some

addi-tional examples of constraints that are not allowed

Operator Constraints Are Not Allowed

Another restriction on constraints is that you cannot specify a constraint

that a class supports on a particular method or operator, unless that

method or operator is on an interface Because of this, the generic Add() in

Listing 11.29 does not work

Listing 11.29: Constraint Expressions Cannot Require Operators

public abstract class MathEx<T>

{

public static T Add(T first, T second)

{

// Error: Operator '+' cannot be applied to

// operands of type 'T' and 'T'.

}

}

In this case, the method assumes that the + operator is available on all

types However, because all types support only the methods of object

(which does not include the + operator), an error occurs Unfortunately,

there is no way to specify the + operator within a constraint; therefore,

creating an add method in this way is a lot more cumbersome One

rea-son for this limitation is that there is no way to constrain a type to have a

static method You cannot, for example, specify static methods on an

interface

return first + second;

Chapter 11: Generics

450

OR Criteria Are Not Supported

If you supply multiple interfaces or class constraints for a type parameter,

the compiler always assumes an AND relationship between constraints

For example, where T : IComparable<T>, IFormattable requires that

both IComparable<T> and IFormattable are supported There is no way to

specify an OR relationship between constraints Hence, an equivalent of

Listing 11.30 is not supported

Listing 11.30: Combining Constraints Using an OR Relationship Is Not Allowed

public class BinaryTree<T>

// Error: OR is not supported.

where T: System.IComparable<T> || System.IFormattable

{

}

Supporting this would prevent the compiler from resolving which method

to call at compile time

Constraints of Type Delegate and Enum Are Not Valid

Readers who are already familiar with C# 1.0 and are reading this chapter

to learn newer features will be familiar with the concept of delegates,

which are covered in Chapter 12 One additional constraint that is not

allowed is the use of any delegate type as a class constraint For example,

the compiler will output an error for the class declaration in Listing 11.31

Listing 11.31: Inheritance Constraints Cannot Be of Type System.Delegate

// Error: Constraint cannot be special class 'System.Delegate'

public class Publisher<T>

where T : System.Delegate

{

public event T Event;

public void Publish()

All delegate types are considered special classes that cannot be specified as

type parameters Doing so would prevent compile-time validation on the

call to Event() because the signature of the event firing is unknown with

the data types System.Delegate and System.MulticastDelegate The

same restriction occurs for any enum type

Constructor Constraints Are Allowed Only for Default Constructors

Listing 11.26 includes a constructor constraint that forces TValue to

sup-port a default constructor There is no constraint to force TValue to support

a constructor other than the default For example, it is not possible to make

EntityBase.Key protected and only set it in a TValue constructor that takes

a TKey parameter using constraints alone Listing 11.32 demonstrates the

invalid code

Listing 11.32: Constructor Constraints Can Be Specified Only for Default Constructors

public TValue New(TKey key)

{

Add(newEntity.Key, newEntity);

return newEntity;

}

One way to circumvent this restriction is to supply a factory interface that

includes a method for instantiating the type The factory implementing the

interface takes responsibility for instantiating the entity rather than the

EntityDictionary itself (see Listing 11.33)

Listing 11.33: Using a Factory Interface in Place of a Constructor Constraint

public class EntityBase<TKey>

{

public TKey Key

{

get { return _key; }

set { _key = value; }

where TKey : IComparable<T>, IFormattable

// Error: 'TValue': Cannot provide arguments

// when creating an instance of a variable type.

TValue newEntity = null;

// newEntity = new TValue(key);

public EntityBase(TKey key)

{

Key = key;

}

A declaration such as this allows you to pass the new key to a TValue

con-structor that takes parameters rather than the default concon-structor It no

longer uses the constructor constraint on TValue because TFactory is

responsible for instantiating the order instead of EntityDictionary< >

(One modification to the code in Listing 11.33 would be to save a copy of

the factory This would enable you to reuse the factory instead of

reinstan-tiating it every time.)

A declaration for a variable of type EntityDictionary<TKey, TValue,

TFactory> would result in an entity declaration similar to the Order entity

in Listing 11.34

Listing 11.34: Declaring an Entity to Be Used in EntityDictionary< >

public class Order : EntityBase<Guid>

where TValue : EntityBase<TKey>

where TFactory : IEntityFactory<TKey, TValue>, new()

TValue newEntity = new TFactory().CreateNew(key);

public interface IEntityFactory<TKey, TValue>

{

TValue CreateNew(TKey key);

}

Generic Methods

You already learned that it is relatively simple to add a generic method to a

class when the class is a generic You did this in the generic class examples

so far, and it also works for static methods Furthermore, you can use

generic classes within a generic class, as you did in earlier BinaryTree

list-ings using the following line of code:

public Pair< BinaryTree<T> > SubItems;

Generic methods are methods that use generics even when the

contain-ing class is not a generic class or the method contains type parameters not

included in the generic class type parameter list To define generic

meth-ods, you add the type parameter syntax immediately following the

method name, as shown in the MathEx.Max<T> and MathEx.Min<T>

exam-ples in Listing 11.35

Listing 11.35: Defining Generic Methods

public static class MathEx

You use the same syntax on a generic class when the method requires an

additional type parameter not included in the class type parameter list In

this example, the method is static but C# does not require this

Note that generic methods, like classes, can include more than one type

parameter The arity (the number of type parameters) is an additional

dis-tinguishing characteristic of a method signature

The output to Listing 11.36 appears in Output 11.4

Not surprisingly, the type parameters, int and string, correspond to

the actual types used in the generic method calls However, specifying the

type is redundant because the compiler can infer the type from the

param-eters passed to the method To avoid redundancy, you can exclude the

type parameters from the call This is known as type inferencing, and an

example appears in Listing 11.37 The output appears in Output 11.5

Listing 11.37: Inferring the Type Parameter

For type inferencing to be successful, the types must match the method

signature However, starting with C# 3.0, the compiler added an

enhance-ment to imply the type parameter as long as the types were implicitly

com-patible For example, calling the Max<T> method using MathEx.Max(7.0,

490) will compile successfully Even though the parameters are not both

the same type (int and double), they will both implicitly convert to

dou-ble, so the method call compiles You can resolve the error by either

cast-ing explicitly or includcast-ing the type argument Also note that you cannot

perform type inferencing purely on the return type Parameters are

required for type inferencing to be allowed

Specifying Constraints

The generic method also allows constraints to be specified For example,

you can restrict a type parameter to implement IComparable<T> The

con-straint is specified immediately following the method header, prior to the

curly braces of the method block, as shown in Listing 11.38

Listing 11.38: Specifying Constraints on Generic Methods

public class ConsoleTreeControl

{

// Generic method Show<T>

public static void Show<T>(BinaryTree<T> tree, int indent)

Chapter 11: Generics

456

Notice that the Show<T> implementation itself does not use the

ICompara-ble<T> interface Recall, however, that the BinaryTree<T> class did require

this (see Listing 11.39)

Listing 11.39: BinaryTree<T> Requiring IComparable<T> Type Parameters

public class BinaryTree<T>

{

}

Because the BinaryTree<T> class requires this constraint on T, and

because Show<T> uses BinaryTree<T>, Show<T> also needs to supply the

constraint

A D V A N C E D T O P I C

Casting inside a Generic Method

Sometimes you should be wary of using generics—for instance, when

using it specifically to bury a cast operation Consider the following

method, which converts a stream into an object:

public static T Deserialize<T>(

Stream stream, IFormatter formatter)

{

return (T)formatter.Deserialize(stream);

}

The formatter is responsible for removing data from the stream and

con-verting it to an object The Deserialize() call on the formatter returns

data of type object A call to use the generic version of Deserialize()

looks something like this:

string greeting =

Deserialization.Deserialize<string>(stream, formatter);

The problem with this code is that to the user of the method,

Deserial-ize<T>() appears to be strongly typed However, a cast operation is still

where T: System.IComparable<T>

Covariance and Contravariance 457

performed implicitly rather than explicitly, as in the case of the nongeneric

equivalent shown here:

string greeting =

(string)Deserialization.Deserialize(stream, formatter);

A method using an explicit cast is more explicit about what is taking place

than is a generic version with a hidden cast Developers should use care

when casting in generic methods if there are no constraints to verify cast

validity

Covariance and Contravariance

If you declare two variables with different type parameters using the

same generic class, the variables are not type-compatible even if they are

assigning from a more specific type to a more generic type—in other

words, they are not covariant For example, instances of a generic class,

Pair<Contact> and Pair<PdaItem>, are not type-compatible even when

the type parameters are compatible In other words, the compiler prevents

casting (implicitly or explicitly) Pair<Contact> to Pair<PdaItem>, even

though Contact derives from PdaItem Similarly, casting Pair<Contact>

to IPair<PdaItem> will also fail (see Listing 11.40)

Listing 11.40: Conversion between Generics with Different Type Parameters

//

// Error: Cannot convert type

Pair<PdaItem> pair = (Pair<PdaItem>) new Pair<Contact>();

IPair<PdaItem> duple = (IPair<PdaItem>) new Pair<Contact>();

To allow covariance such as this would allow the following (see Listing

Thus, casting Pair<Contact> to IPair<PdaItem> would appear to allow

Pair<Contact> to contain heterogeneous data rather than just with the

Contact type as the type parameter specified Although a failure would

still occur at runtime, the compile time validation is preferable

Similarly, the compiler prevents contravariance, or assigning of types

from more generic to more specific For example, the following will cause a

compile error:

Pair<Contact> contacts = (IPair<PdaItem>) pdaPair;

Doing so would cause a similar problem to covariance Items within

pda-Pair could potentially be heterogeneous (addresses and contacts) and

con-straining to all contacts would be invalid

Enabling Covariance with the out Type Parameter Modifier in C# 4.0

It is important to note that you can define an IReadOnlyPair<T> interface

that doesn’t encounter the covariance problem The IReadOnlyPair<T>

interfaces would only expose T out of the interface (return parameters or

get property members) and never into it (input parameters or set property

members) In so doing, the covariance problem just described would not

occur (see Listing 11.42)

Listing 11.42: Potentially Possible Covariance

T First { get; set; }

T Second { get; set; }

}

// Error: Cannot convert type

IPair<PdaItem> pdaPair = (IPair<PdaItem>) contacts;

pair.First = address;

Covariance and Contravariance 459

public struct Pair<T> : IPair<T>, IReadOnlyPair<T>

// Error: Only theoretically possible without

// the out type parameter modifier

}

}

By restricting the generic type declaration to only expose data out of the

interface, there is no reason for the compiler to prevent covariance All

operations on an IReadOnlyPair<PdaItem> instance would convert

Con-tacts (from the original Pair<Contact> object) up to the base class

PdaItem—a perfectly valid conversion

Support for valid covariance, in which the assigned type only exposed

data out, was added to C# 4 with the out type parameter modifier (see

T First { get; set; }

T Second { get; set; }

}

Pair<Contact> contacts =

new Pair<Contact>(

new Contact("Princess Buttercupt"),

new Contact("Inigo Montoya") );

IReadOnlyPair<PdaItem> pair = contacts;

PdaItem pdaItem1 = pair.First;

PdaItem pdaItem2 = pair.Second;

interface IReadOnlyPair<out T>

new Contact("Princess Buttercup"),

new Contact("Inigo Montoya") );

PdaItem pdaItem1 = pair.First;

PdaItem pdaItem2 = pair.Second;

}

}

Modifying the type parameter on the IReadOnlyPair<out T> interface

with out will cause the compiler to verify that indeed, T is used only for

member returns and property getters, never for input parameters or

prop-erty setters From then on, the compiler will allow any covariant

assign-ments to the interface

Enabling Contravariance with the in Type Parameter Modifier in C# 4.0

As I mentioned earlier, contravariance is also invalid A Pair<PdaItem>

could potentially be heterogeneous (containing both an Address and a

Contact), and constraining it to only be Contacts when it contains

Addresses would invalid However, imagine an IWriteOnlyPair<T> (see

Listing 11.44) such that through this interface only Contacts could be

placed into First and Second What was already stored within

Pair<PdaItem> would be irrelevant (since IWriteOnlyPair<T> can’t

retrieve it), and assigning an Address directly via the Pair<PdaItem>

would also not affect the validity of what the IWriteOnlyPair<T> allowed

Listing 11.44: Covariance Using the out Type Parameter Modifier

T First { get; set; }

T Second { get; set; }

}

public struct Pair<T>

: IPair<T>, IReadOnlyPair<out T>, IWriteOnlyPair<in T>

Pair<Contact> contacts = new Pair<PdaItem>(

new Address(" "), new Contact(" "));;

contacts.First = new Contact("Inigo Montoya");

contacts.Second = new Contact("Princess Buttercup");

}

}

Since Pair<PdaItem> could safely contain any PdaItem, forcing only

Con-tacts to be inserted would be valid The invalid operation would occur

only when retrieving items out of the pair, something that

IWriteOnly-Pair<T> does not allow since it has only property setters

Notice that similar to covariance support, contravariance uses a type

parameter modifier: in, on the IWriteOnlyPair<T> interface This instructs

the compiler to check that T never appears on a property getter or as an out

parameter on a method, thus enabling contravariance to the interface

Not surprisingly, the covariance and contravariance type modifiers can

be combined into the same interface Imagine, for example, the

IConvert-ible<in TSource, out TTarget> interface defined in Listing 11.45

Chapter 11: Generics

462

Listing 11.45: Covariance Using the out Type Parameter Modifier

interface IConvertible<in TSource, out TTarget>

{

TTarget Convert(TSource source);

}

Using this interface with the type parameter modifiers specified would

enable a successful conversion from an IConvertible<PdaItem, Contact>

to an IConvertible<Contact, PdaItem>

Lastly, notice that the compiler will check validity of the covariance and

contravariance type parameter modifiers throughout the source Consider

the PairInitializer<in T> interface in Listing 11.46

Listing 11.46: Covariance Using the out Type Parameter Modifier

// ERROR: Invalid variance, the type parameter 'T' is not

A casual observer may be tempted to think that since IPair<T> is only

an input parameter, restricting T to in on PairInitializer is valid

How-ever, inside the implementation of Initialize() we would expect to

assign First and Second, thereby introducing the potential of assigning a

value that does not convert to T

Support for Parameter Covariance and Contravariance in Arrays

Unfortunately, ever since C# 1.0, arrays allowed for covariance and

contra-variance For example, both PdaItem[] pdaItems = new Contact[] { }

and Contact[] contacts = (Contact[])new PdaItem[] { } are valid

assignments in spite of the negative implications discussed earlier The

result is that the covariant and contravariant restrictions imposed by the

compiler in C# 2.0 and the loosening of those restrictions in C# 4.0 to

enable valid scenarios do not apply to arrays As regrettable as this is, the

situation can be avoided As Chapter 14 describes, a host of interfaces and

collections are available that effectively supersede arrays and enable a

super set of functionality Support for generics in combination with C# 3.0

Generic Internals 463

syntax for initializing arrays (see Collection Initializers in Chapter 14)

eliminates any best practice use of arrays except when required by existing

interfaces Moving forward, arrays may be treated as deprecated

Generic Internals

Given the discussions in earlier chapters about the prevalence of objects

within the CLI type system, it is no surprise that generics are also objects

In fact, the type parameter on a generic class becomes metadata that the

runtime uses to build appropriate classes when needed Generics,

there-fore, support inheritance, polymorphism, and encapsulation With

gener-ics, you can define methods, properties, fields, classes, interfaces, and

delegates

To achieve this, generics require support from the underlying runtime

So, the addition of generics to the C# language is a feature of both the

com-piler and the platform To avoid boxing, for example, the implementation

of generics is different for value-based type parameters than for generics

with reference type parameters

A D V A N C E D T O P I C

CIL Representation of Generics

When a generic class is compiled, it is no different from a regular class The

result of the compilation is nothing but metadata and CIL The CIL is

parameterized to accept a user-supplied type somewhere in code Suppose

you had a simple Stack class declared as shown in Listing 11.47

Listing 11.47: Stack<T> Declaration

public class Stack<T> where T : IComparable

{

T[] items;

// rest of the class here

}

When you compile the class, the generated CIL is parameterized and looks

something like Listing 11.48

Chapter 11: Generics

464

Listing 11.48: CIL Code for Stack<T>

.class private auto ansi beforefieldinit

The first notable item is the '1 that appears following Stack on the second

line That number is the arity It declares the number of parameter types

that the generic class will include A declaration such as

EntityDiction-ary<TKey, TValue> would have an arity of 2

In addition, the second line of the generated CIL shows the constraints

imposed upon the class The T type parameter is decorated with an

inter-face declaration for the IComparable constraint

If you continue looking through the CIL, you will find that the item’s

array declaration of type T is altered to contain a type parameter using

“exclamation point notation,” new to the generics-capable version of the

CIL The exclamation point denotes the presence of the first type

parame-ter specified for the class, as shown in Listing 11.49

Listing 11.49: CIL with “Exclamation Point Notation” to Support Generics

.class public auto ansi beforefieldinit

Beyond the inclusion of the arity and type parameter in the class header

and the type parameter denoted with exclamation points in code, there is

little difference between the CIL generated for a generic class and the CIL

generated for a nongeneric class

Instantiating Generics Based on Value Types

When a generic type is first constructed with a value type as a type

param-eter, the runtime creates a specialized generic type with the supplied type

.field private !0[ ] items

Generic Internals 465

parameter(s) placed appropriately in the CIL Therefore, the runtime

cre-ates new specialized generic types for each new parameter value type

For example, suppose some code declared a Stack constructed of

inte-gers, as shown in Listing 11.50

Listing 11.50: Stack<int> Definition

Stack<int> stack;

When using this type, Stack<int>, for the first time, the runtime generates

a specialized version of the Stack class with int substituted for its type

parameter From then on, whenever the code uses a Stack<int>, the

run-time reuses the generated specialized Stack<int> class In Listing 11.51,

you declare two instances of a Stack<int>, both using the code already

generated by the runtime for a Stack<int>

Listing 11.51: Declaring Variables of Type Stack<T>

Stack<int> stackOne = new Stack<int>();

Stack<int> stackTwo = new Stack<int>();

If later in the code, you create another Stack with a different value type

as its type parameter (such as a long or a user-defined struct) the runtime

generates another version of the generic type The benefit of specialized

value type classes is better performance Furthermore, the code is able to

avoid conversions and boxing because each specialized generic class

“natively” contains the value type

Instantiating Generics Based on Reference Types

Generics work slightly differently for reference types The first time a

generic type is constructed with a reference type, the runtime creates a

specialized generic type with object references substituted for type

parameters in the CIL, not a specialized generic type based on the type

parameter Each subsequent time a constructed type is instantiated with a

reference type parameter, the runtime reuses the previously generated

version of the generic type, even if the reference type is different from the

first reference type

Chapter 11: Generics

466

For example, suppose you have two reference types, a Customer class

and an Order class, and you create an EntityDictionary of Customer

types, like so:

EntityDictionary<Guid, Customer> customers;

Prior to accessing this class, the runtime generates a specialized version of

the EntityDictionary class that, instead of storing Customer as the

speci-fied data type, stores object references Suppose the next line of code

cre-ates an EntityDictionary of another reference type, called Order:

EntityDictionary<Guid, Order> orders =

new EntityDictionary<Guid, Order>();

Unlike value types, no new specialized version of the EntityDictionary

class is created for the EntityDictionary that uses the Order type Instead,

an instance of the version of EntityDictionary that uses object references

is instantiated and the orders variable is set to reference it

To still gain the advantage of type safety, for each object reference

substituted in place of the type parameter, an area of memory for an

Order type is specifically allocated and the pointer is set to that memory

reference

Suppose you then encountered a line of code to instantiate an

Entity-Dictionary of a Customer type as follows:

customers = new EntityDictionary<Guid, Customer>();

As with the previous use of the EntityDictionary class created with the

Order type, another instance of the specialized EntityDictionary class

(the one based on object references) is instantiated and the pointers

con-tained therein are set to reference a Customer type specifically This

imple-mentation of generics greatly reduces code bloat by reducing to one the

number of specialized classes created by the compiler for generic classes of

reference types

Even though the runtime uses the same internal generic type definition

when the type parameter on a generic reference type varies, this behavior

is superseded if the type parameter is a value type Dictionary<int,

Customer>, Dictionary<Guid, Order>, and Dictionary<long, Order> will

require new internal type definitions, for example

SUMMARY

Generics transformed C# 1.0 coding style In virtually all cases in which

programmers used object within C# 1.0 code, generics became a better

choice in C# 2.0 and later to the extent that using object in relation to

col-lections, at a minimum, should act as a flag for a possible generics

imple-mentation The increased type safety, cast avoidance, and reduction of

code bloat offer significant improvements Similarly, where code

tradition-ally used the System.Collections namespace, System.Collections.

Generics should be selected instead

Language Contrast: Java—Generics

Sun’s implementation of generics for Java occurs within the compiler

entirely, not within the Java Virtual Machine Sun did this to ensure that no

updated Java Virtual Machine would need to be distributed because

gener-ics were used

The Java implementation uses syntax similar to the templates in C++

and the generics in C#, including type parameters and constraints But

because it does not treat value types differently from reference types, the

unmodified Java Virtual Machine cannot support generics for value types

As such, generics in Java do not gain the execution efficiency of C#

Indeed, whenever the Java compiler needs to return data, it injects

auto-matic downcasts from the specified constraint, if one is declared, or the

base Object type if it is not declared Further, the Java compiler

gener-ates a single specialized type at compile time, which it then uses to

instantiate any constructed type Finally, because the Java Virtual

Machine does not support generics natively, there is no way to ascertain

the type parameter for an instance of a generic type at execution time,

and other uses of reflection are severely limited

Chapter 11: Generics

468

Chapter 16 looks at one of the most pervasive generic namespaces,

Sys-tem.Collections.Generic This namespace is composed almost

exclu-sively of generic types It provides clear examples of how some types that

originally used objects were then converted to use generics However,

before we tackle these topics, we will investigate expressions, which provide

a significant C# 3.0 (and later) improvement for working with collections

REVIOUS CHAPTERS DISCUSSED extensively how to create classes

using many of the built-in C# language facilities for object-oriented

development The objects instantiated from classes encapsulate data and

operations on data As you create more and more classes, you see common

patterns in the relationships between these classes

One such pattern is to pass an object that represents a method that the

receiver can invoke The use of methods as a data type and their support

for publish-subscribe patterns is the focus of this chapter Both C# 2.0 and

C# 3.0 introduced additional syntax for programming in this area

Although C# 3.0 supports the previous syntax completely, in many cases

C# 3.0 will deprecate the use of the older-style syntax However, I have

P

2 3

4

Delegates and Lambda Expressions

Introducing Delegates

Why Delegates Delegate As Data Types Delegate Internals Instantiating Delegates

Anonymous Methods Statement Lambdas

Expression

Lambdas

Expression Trees

Chapter 12: Delegates and Lambda Expressions

470

placed the earlier syntax into Advanced Topic blocks, which you can

largely ignore unless you require support for an earlier compiler

Introducing Delegates

Veteran C and C++ programmers have long used method pointers as a

means to pass executable steps as parameters to another method C#

achieves the same functionality using a delegate, which encapsulates

methods as objects, enabling an indirect method call bound at runtime

Consider an example of where this is useful

Defining the Scenario

Although not necessarily efficient, perhaps one of the simplest sort

rou-tines is a bubble sort Listing 12.1 shows the BubbleSort() method

Listing 12.1: BubbleSort() Method

static class SimpleSort1

Introducing Delegates 471

This method will sort an array of integers in ascending order

However, if you wanted to support the option to sort the integers in

descending order, you would have essentially two options You could

duplicate the code and replace the greater-than operator with a less-than

operator Alternatively, you could pass in an additional parameter

indicat-ing how to perform the sort, as shown in Listindicat-ing 12.2

Listing 12.2: BubbleSort() Method, Ascending or Descending

However, this handles only two of the possible sort orders If you wanted

to sort them alphabetically, randomize the collection, or order them via

some other criterion, it would not take long before the number of

Bubble-Sort() methods and corresponding SortType values would become

cumbersome

Delegate Data Types

To increase the flexibility (and reduce code duplication), you can pass

in the comparison method as a parameter to the BubbleSort() method

Moreover, in order to pass a method as a parameter, there needs to be

a data type that can represent that method—in other words, a delegate

Listing 12.3 includes a modification to the BubbleSort() method that

takes a delegate parameter In this case, the delegate data type is

public static void BubbleSort(

int[] items, ComparisonHandler comparisonMethod)

ComparisonHandler is a data type that represents a method for comparing

two integers Within the BubbleSort() method you then use the instance

of the ComparisonHandler, called comparisonMethod, inside the conditional

expression Since comparisonMethod represents a method, the syntax to

invoke the method is identical to calling the method directly In this case,

comparisonMethod takes two integer parameters and returns a Boolean

value that indicates whether the first integer is greater than the second one

Perhaps more noteworthy than the particular algorithm, the

Compari-sonHandler delegate is strongly typed to return a bool and to accept only

two integer parameters Just as with any other method, the call to a delegate

is strongly typed, and if the data types do not match up, then the C#

com-piler reports an error Let us consider how the delegate works internally

Delegate Internals

C# defines all delegates, including ComparisonHandler, as derived

indi-rectly from System.Delegate, as shown in Figure 12.1.1

The first property is of type System.Reflection.MethodInfo, which I

cover in Chapter 17 MethodInfo describes the signature of a particular

method, including its name, parameters, and return type In addition to

if (comparisonMethod(items[j - 1], items[j]))

1 The C# standard doesn’t specify the delegate implementation’s class hierarchy .NET’s

implementation, however, does derive indirectly from System.Delegate

Chapter 12: Delegates and Lambda Expressions

474

MethodInfo, a delegate also needs the instance of the object containing

the method to invoke This is the purpose of the second property, Target

In the case of a static method, Target corresponds to the type itself

The purpose of the MulticastDelegate class is the topic of the next

chapter

It is interesting to note that all delegates are immutable “Changing” a

delegate involves instantiating a new delegate with the modification

included

Defining a Delegate Type

You saw how to define a method that uses a delegate, and you learned

how to invoke a call to the delegate simply by treating the delegate

variable as a method However, you have yet to learn how to declare a

del-egate data type For example, you have not learned how to define

ComparisonHandler such that it requires two integer parameters and

returns a bool

Although all delegate data types derive indirectly from System.Delegate,

the C# compiler does not allow you to define a class that derives directly or

indirectly (via System.MulticastDelegate) from System.Delegate Listing

12.4, therefore, is not valid

Figure 12.1: Delegate Types Object Model

Introducing Delegates 475

Listing 12.4: System.Delegate Cannot Explicitly Be a Base Class

// ERROR: 'ComparisonHandler' cannot

// inherit from special class 'System.Delegate'

public class ComparisonHandler: System.Delegate

{

//

}

In its place, C# uses the delegate keyword This keyword causes the

compiler to generate a class similar to the one shown in Listing 12.4

Listing 12.5 shows the syntax for declaring a delegate data type

Listing 12.5: Declaring a Delegate Data Type

public delegate bool ComparisonHandler (

int first, int second);

In other words, the delegate keyword is shorthand for declaring a

refer-ence type derived ultimately from System.Delegate In fact, if the delegate

declaration appeared within another class, then the delegate type,

Compar-isonHandler, would be a nested type (see Listing 12.6)

Listing 12.6: Declaring a Nested Delegate Data Type

class DelegateSample

{

public delegate bool ComparisonHandler (

int first, int second);

}

In this case, the data type would be DelegateSample.ComparisonHandler

because it is defined as a nested type within DelegateSample

Instantiating a Delegate

In this final step of implementing the BubbleSort() method with a

delegate, you will learn how to call the method and pass a delegate

instance—specifically, an instance of type ComparisonHandler To

instanti-ate a deleginstanti-ate, you need a method that corresponds to the signature of the

delegate type itself In the case of ComparisonHandler, that method takes

two integers and returns a bool The name of the method is not significant

Listing 12.7 shows the code for a greater-than method

Chapter 12: Delegates and Lambda Expressions

476

Listing 12.7: Declaring a ComparisonHandler-Compatible Method

public delegate bool ComparisonHandler (

int first, int second);

class DelegateSample

{

public static void BubbleSort(

int[] items, ComparisonHandler comparisonMethod)

With this method defined, you can call BubbleSort() and pass the

dele-gate instance that contains this method Beginning with C# 2.0, you simply

specify the name of the delegate method (see Listing 12.8)

Listing 12.8: Passing a Delegate Instance As a Parameter in C# 2.0

public delegate bool ComparisonHandler (

int first, int second);

class DelegateSample

{

public static void BubbleSort(

int[] items, ComparisonHandler comparisonMethod)

int[] items = new int[100];

Random random = new Random();

public static bool GreaterThan(int first, int second)

Note that the ComparisonHandler delegate is a reference type, but you

do not necessarily use new to instantiate it The facility to pass the name

instead of using explicit instantiation is called delegate inference, a new

syntax beginning with C# 2.0 With this syntax, the compiler uses the

method name to look up the method signature and verify that it matches

the method’s parameter type

A D V A N C E D T O P I C

Delegate Instantiation in C# 1.0

Earlier versions of the compiler require instantiation of the delegate

dem-onstrated in Listing 12.9

Listing 12.9: Passing a Delegate Instance As a Parameter Prior to C# 2.0

public delegate bool ComparisonHandler (

int first, int second);

class DelegateSample

{

public static void BubbleSort(

int[] items, ComparisonHandler comparisonMethod)

Note that C# 2.0 and later support both syntaxes, but unless you are

writ-ing backward-compatible code, the 2.0 syntax is preferable Therefore,

throughout the remainder of the book, I will show only the C# 2.0 and later

syntax (This will cause some of the remaining code not to compile on

ver-sion 1.0 compilers, unless you modify those compilers to use explicit

dele-gate instantiation.)

The approach of passing the delegate to specify the sort order is

significantly more flexible than the approach listed at the beginning of

this chapter With the delegate approach, you can change the sort order to

be alphabetical simply by adding an alternative delegate to convert integers

to strings as part of the comparison Listing 12.10 shows a full listing that

demonstrates alphabetical sorting, and Output 12.1 shows the results

Listing 12.10: Using a Different ComparisonHandler-Compatible Method

Introducing Delegates 479

public delegate bool ComparisonHandler(int first, int second);

public static void BubbleSort(

int[] items, ComparisonHandler comparisonMethod)

public static bool AlphabeticalGreaterThan(

int first, int second)

The alphabetic order is different from the numeric order Note how simple

it was to add this additional sort mechanism, however, compared to the

process used at the beginning of the chapter

The only changes to create the alphabetical sort order were the addition

of the AlphabeticalGreaterThan method and then passing that method

into the call to BubbleSort()

Anonymous Methods

C# 2.0 and later include a feature known as anonymous methods These

are delegate instances with no actual method declaration Instead, they are

defined inline in the code, as shown in Listing 12.11

Listing 12.11: Passing an Anonymous Method

int i;

int[] items = new int[5];

for (i=0; i<items.Length; i++)

In Listing 12.11, you change the call to BubbleSort() to use an anonymous

method that sorts items in descending order Notice that no LessThan()

method is specified Instead, the delegate keyword is placed directly

inline with the code In this context, the delegate keyword serves as a

means of specifying a type of “delegate literal,” similar to how quotes

specify a string literal

You can even call the BubbleSort() method directly, without declaring

the comparisonMethod variable (see Listing 12.12)

Listing 12.12: Using an Anonymous Method without Declaring a Variable

Note that in all cases, the parameter types and the return type must be

compatible with the ComparisonHandler data type, the delegate type of the

second parameter of BubbleSort()

In summary, C# 2.0 included a new feature, anonymous methods, that

provided a means to declare a method with no name and convert it into a

delegate

A D V A N C E D T O P I C

Parameterless Anonymous Methods

Compatibility of the method signature with the delegate data type does

not exclude the possibility of no parameter list Unlike with lambda

expressions, statement lambdas, and expression lambdas (see the next

section), anonymous methods are allowed to omit the parameter list

(delegate { return Console.ReadLine() != ""}, for example) This is

atypical, but it does allow the same anonymous method to appear in

multiple scenarios even though the delegate type may vary Note,

however, that although the parameter list may be omitted, the return type

will still need to be compatible with that of the delegate (unless an