You saw in Chapter 10 that arrays are useful for when you have a group of objects of the same type, and you need to treat them as a group—as a collection. Arrays are the least flexible of the five standard collections used in C# 2005:
Array
List
Stack
Queue
Dictionary
This chapter will introduce each of the latter four collections, and will show how the new feature generics are used to make these collections type-safe (and why type-safety is important!).
You can also create classes that act like
collections, and you can provide support for your collection classes so
that they support some or all of the behavior expected of collections like
the ability to be used in a foreach
loop or to access their members using an indexer:
Employee joe = MyCompany[EmployeeID]
Until generics, all the collection classes (ArrayList, Stack, and Queue) were defined to hold objects of type
Object (the root class). Thus, you
could add integers and strings to the same class, and when you took
items out of the collection, you had to cast them to their “real” type.
This was ugly, and it was error-prone (the compiler could not tell if
you had a collection of integers and added a string).
With generics, the designer of the class (the person who creates
the Stack class) can say, “This class
will hold only one type, and that type will be defined by the developer
who makes an instance of this class.”
The user of the generic Stack
class defines an instance of the Stack and the type it will hold, and the
compiler can now use this type-safe Stack to ensure that only objects of the
designated type are stored in the collection. Much better.
The designer adds a type placeholder (technically called a type parameter):
class Stack<T>
The user of the Stack class
puts in the actual type when instantiating the class, like this:
class Stack<Employee> = new Stack<Employee>