The Queue data type expects the items it holds to be reference types. Enqueueing a value type, such as an int, requires it to be boxed to convert it to a reference type. Similarly, dequeueing into an int requires the item to be unboxed to convert it back to a value type. See the sections titled “Boxing” and “Unboxing” in Chapter 8 for more details. Although boxing and unboxing happen transparently, they add a performance overhead because they involve dynamic memory allocations. This overhead is small for each item, but it adds up when a program creates queues of large numbers of value types.

The Generics Solution

C# provides generics to remove the need for casting, improve type safety, reduce the

amount of boxing required, and make it easier to create generalized classes and methods. Generic classes and methods accept type parameters, which specify the type of objects that

they operate on. The .NET Framework class library includes generic versions of many of the collection classes and interfaces in the System.Collections.Generic namespace. The following code example shows how to use the generic Queue class found in this namespace to create a queue of Circle objects:

using System.Collections.Generic;

...

Queue<Circle> myQueue = new Queue<Circle>(); Circle myCircle = new Circle(); myQueue.Enqueue(myCircle);

...

myCircle = myQueue.Dequeue();

There are two new things to note about the code in the preceding example:

The use of the type parameter between the angle brackets, <Circle>, when declaring the myQueue variable

The lack of a cast when executing the Dequeue method

The type parameter in angle brackets specifies the type of objects accepted by the queue.

All references to methods in this queue will automatically expect to use this type rather than object, rendering unnecessary the cast to the Circle type when invoking the Dequeue

method. The compiler will check to ensure that types are not accidentally mixed and will

generate an error at compile time rather than at run time if you try to dequeue an item from circleQueue into a Clock object, for example.

If you examine the description of the generic Queue class in the Microsoft Visual Studio 2008 documentation, you will notice that it is defined as follows:

public class Queue<T> : ...

336 Part III Creating Components

The T identifies the type parameter and acts as a placeholder for a real type at compile time. When you write code to instantiate a generic Queue, you provide the type that should be substituted for T (Circle in the preceding example). Furthermore, if you then look at the methods of the Queue<T> class, you will observe that some of them, such as Enqueue and Dequeue, specify T as a parameter type or return value:

public void Enqueue( T item ); public T Dequeue();

The type parameter, T, will be replaced with the type you specified when you declared the queue. What is more, the compiler now has enough information to perform strict type checking when you build the application and can trap any type mismatch errors early.

You should also be aware that this substitution of T for a specified type is not simply a textual replacement mechanism. Instead, the compiler performs a complete semantic substitution so that you can specify any valid type for T. Here are more examples:

struct Person

{

...

}

...

Queue<int> intQueue = new Queue<int>(); Queue<Person> personQueue = new Queue<Person>();

Queue<Queue<int>> queueQueue = new Queue<Queue<int>>();

The first two examples create queues of value types, while the third creates a queue of queues (of ints). For example, for the intQueue variable the compiler will also generate the following versions of the Enqueue and Dequeue methods:

public void Enqueue( int item ); public int Dequeue();

Contrast these definitions with those of the nongeneric Queue class shown in the preceding section. In the methods derived from the generic class, the item parameter to Enqueue is passed as a value type that does not require boxing. Similarly, the value returned by Dequeue

is also a value type that does not need to be unboxed.

It is also possible for a generic class to have multiple type parameters. For example, the generic System.Collections.Generic.Dictionary class expects two type parameters: one type for

keys and another for the values. The following definition shows how to specify multiple type parameters:

public class Dictionary<TKey, TValue>

A dictionary provides a collection of key/value pairs. You store values (type TValue) with an associated key (type TKey) and then retrieve them by specifying the key to look up. The