Section 2.5. Build Typesafe Generic Classes | Visual Basic 2005: A Developers Notebook

2.5. Build Typesafe Generic Classes

Programmers often face a difficult choice. On one hand, it's keenly important to build solutions that are as generic as possible, so that they can be reused in different scenarios. For example, why build a CustomerCollection class that accepts only objects of type Customer when you can build a generic Collection class that can be configured to accept objects of any type? On the other hand, performance and type safety considerations can make a generic solution less desirable. If you use a generic .NET Collection class to store Customer objects, for example, how can you be sure that someone won't accidentally insert another type of object into the collection, causing an insidious problem later on?

Note: Need to create a class that's flexible enough to work with any type of object, but able to restrict the objects it accepts in any given instance? With generics, VB has the perfect solution.

Visual Basic 2005 and .NET 2.0 provide a solution called generics. Generics are classes that are parameterized by type. In other words, generics allow you to create a class template that supports any type. When you instantiate that class, you specify the type you want to use, and from that point on, your object is "locked in" to the type you chose.

2.5.1. How do I do that?

An example of where the use of generics makes great sense is the System.Collections.ArrayList class. ArrayList is an all-purpose, dynamically self-sizing collection. It can hold ordinary .NET objects or your own custom objects. In order to support this, ArrayList treats everything as the base Object type.

The problem is that there's no way to impose any restrictions on how ArrayList works. For example, if you want to use ArrayList to store a collection of Customer objects, you have no way to be sure that a faulty piece of code won't accidentally insert strings, integers, or some other type of object, causing future headaches. For this reason, developers often create their own strongly typed collection classesin fact, the .NET class library is filled with dozens of them.

Generics can solve this problem. For example, using generics you can declare a class that works with any type using the Of keyword:

Public Class GenericList(Of ItemType)     ' (Code goes here) End Class

In this case, you are creating a new class named GenericList that can work with any type of object. However, the client needs to specify what type should be used. In your class code, you refer to that type as ItemType. Of course, ItemType isn't really a typeit's just a placeholder for the type that you'll choose when you instantiate a GenericList object.

Example 2-2 shows the complete code for a simple typesafe ArrayList.

Example 2-2. A typesafe collection using generics

Public Class GenericList(Of ItemType)     Inherits CollectionBase          Public Function Add(ByVal value As ItemType) As Integer         Return List.Add(value)     End Function          Public Sub Remove(ByVal value As ItemType)         List.Remove(value)     End Sub          Public ReadOnly Property Item(ByVal index As Integer) As ItemType         Get             ' The appropriate item is retrieved from the List object and              ' explicitly cast to the appropriate type, and then returned.             Return CType(List.Item(index), ItemType)         End Get     End Property End Class

The GenericList class wraps an ordinary ArrayList, which is provided through the List property of the CollectionBase class it inherits from. However, the GenericList class works differently than an ArrayList by providing strongly typed Add( ) and Remove( ) methods, which use the ItemType placeholder.

Here's an example of how you might use the GenericList class to create an ArrayList collection that only supports strings:

' Create the GenericList instance, and choose a type (in this case, string). Dim List As New GenericList(Of String)      ' Add two strings. List.Add("blue") List.Add("green")      ' The next statement will fail because it has the wrong type. ' There is no automatic way to convert a GUID to a string. ' In fact, this line won't ever run, because the compiler ' notices the problem and refuses to build the application. List.Add(Guid.NewGuid( ))

There's no limit to how many ways you can parameterize a class. In the GenericList example, there's only one type parameter. However, you could easily create a class that works with two or three types of objects, and allows you to make all of these types generic. To use this approach, just separate each parameter type with a comma (between the brackets at the beginning of a class).

For example, consider the following GenericHashTable class, which allows you to define the type of the items the collection will store (ItemType), as well as the type of the keys you will use to index those items (KeyType):

Public Class GenericHashTable(Of ItemType, KeyType)     Inherits DictionaryBase     ' (Code goes here.) End Class

Another important feature in generics is the ability to apply constraints to parameters. Constraints restrict the types allowed for a given generic class. For example, suppose you want to create a class that supports only types that implement a particular interface. To do so, first declare the type or types the class accepts and then use the As keyword to specify the base class that the type must derive from, or the interface that the type must implement.

Here's an example that restricts the items stored in a GenericList to serializable items. This feature would be useful if, for example, you wanted to add a method to the GenericList that required serialization, such as a method that writes all the items in the list to a stream:

Public Class SerializableList(Of ItemType As ISerializable)    Inherits CollectionBase      ' (Code goes here.) End Class

Similarly, here's a collection that can contain any type of object, provided it's derived from the System.Windows.Forms.Control class. The end result is a collection that's limited to controls, like the one exposed by the Forms.Controls property on a window:

Public Class ControlCollection(Of ItemType As Control)    Inherits CollectionBase      ' (Code goes here.) End Class

Sometimes, your generic class might need the ability to create the parameter class. For example, the GenericList example might need the ability to create an instance of the item you want to store in the collection. In this case, you need to use the New constraint. The New constraint allows only parameter types that have a public zero-argument constructor, and aren't marked MustInherit. This ensures that your code can create instances of the parameter type. Here's a collection that imposes the New constraint:

Public Class GenericList(Of ItemType As New)    Inherits CollectionBase      ' (Code goes here.) End Class

It's also worth noting that you can define as many constraints as you want, as long as you group the list of constraints in curly braces, as shown here:

Public Class GenericList(Of ItemType As {ISerializable, New})    Inherits CollectionBase      ' (Code goes here.) End Class

Constraints are enforced by the compiler, so if you violate a constraint rule when using a generic class, you won't be able to compile your application.

Note: Generics are built into the Common Language Runtime. That means they are supported in all first-class . NET languages, including C#.

2.5.2. What about...

...using generics with other code structures? Generics don't just work with classes. They can also be used in structures, interfaces, delegates, and even methods. For more information, look for the index entry "generics" in the MSDN Help. For more in-depth examples of advanced generic techniques, you can refer to a Microsoft whitepaper at http://www.msdn.net/library/en-us/dnvs05/html/vb2005_generics.asp.

Incidentally, the .NET Framework designers are well aware of the usefulness of generic collections, and they've already created several for you to use out of the box. You'll find them in the new Systems.Collections.Generic namespace. They include:

List (a basic collection like the GenericList example)
Dictionary (a name-value collection that indexes each item with a key)
LinkedList (a linked list, where each item points to the next item in the chain)
Queue (a first-in-first-out collection)
Stack (a last-in-first-out collection)
SortedList (a name-value collection that's kept in perpetually sorted order)

Most of these types duplicate one of the types in the System.Collections namespace. The old collections remain for backward compatibility.