A generic class declaration looks a lot like a normal class declaration with one or more generic type variables added in parentheses. For example, the following code shows the basic declaration for a generic TreeNode class:

Public Class TreeNode(Of T)
    ...
End Class

The (Of T) means the class takes one type parameter, T. Within the class's code, the type T means whatever type the program used when creating the instance of the class. For example, the following code declares a variable named rootNode that is a TreeNode that handles strings:

Dim rootNode As New TreeNode(Of String)()

If you want the class to use multiple type parameters, separate them with commas. For example, suppose you want to make a Matcher class that takes two kinds of objects and matches objects of the two kinds. It might match Employee objects with Job objects to assign employees to jobs. The following code shows how you might declare the Matcher class:

Public Class Matcher(Of T1, T2)
    ...
End Class

The following code shows how you might create an instance of the class to match Employees with Jobs:

Dim jobAssigner As New Matcher(Of Employee, Job)

Inside the class's code, you can use the types freely. For example, the following code shows more of the TreeNode class's code. A TreeNode object represents a node in a tree, with an associated piece of data attached to it. The places where the class uses the data type T are highlighted in bold.

Public Class TreeNode(Of T
    ' This node's data.
    Public Property Data As T

    ' This node's children.
    Private Children As New List(Of TreeNode(Of T)()

    ' Initializing constructor.
    Public Sub New(ByVal newData As T
        Data = newData
    End Sub

' Override ToString to display the data.
    Public Overrides Function ToString() As String
        If Data Is Nothing Then Return ""
        Return Data.ToString()
    End Function

    ...
End Class

Notice how the class uses the type T throughout its code. The class starts with a Data property of type T. This is the data (of whatever data type) associated with the node.

Each node also has a list of child nodes that should be other TreeNodes of the same kind as this one. To hold the right kind of objects, the Children variable is a generic List(Of TreeNode(Of T)), meaning it can hold only TreeNode(Of T) objects.

The class's constructor takes a parameter of type T and saves it in the object's Data property.

To make displaying a TreeNode easier, the class overrides its ToString method so it calls the ToString method provided by the Data object. For example, if the object is a TreeNode(Of String), then this simply returns the string's value.

The previous example overrides the TreeNode class's ToString method so it calls the Data object's ToString method. Fortunately, all objects inherit a ToString method from the Object ancestor class so you know this is possible, but what if you want to call some other method provided by the object?

For example, suppose you want to create a new instance of type T by using a parameterless constructor. How do you know type T provides a parameterless constructor? What if you want to compare two objects of type T to see which is greater? Is that possible? Or what if you want to compare two type T objects to see if they are the same (an important test for the Dictionary class)? How do you know whether two type T objects are comparable?

You can use generic constraints to require that the types used by the program meet certain criteria such as comparability or providing a parameterless constructor.

To use a generic constraint, follow the type with the keyword As and the constraint. Some typical constraints include the following:

You can use multiple constraints surrounded with braces and separated by commas.

For example, the following code defines the generic Matcher class, which takes two generic type parameters T1 and T2. (To keep things simple, this code skips important error handling such as checking for null values.)

Public Class Matcher(Of T1 As {IComparable(Of T2), New}, T2 As New)
    Private Sub Test()
        Dim object1 As New T1()
        Dim object2 As New T2()
        ...
        If object1.CompareTo(object2) < 0 Then
            ' The object1 is "less than" object2.
            ...
        End If
    End Sub
    ...
End Class

The first constraint requires that type parameter T1 implement the generic IComparable interface for the type T2 so the code can compare T1 objects to T2 objects. The next constraint requires that the T1 type also provide a parameterless constructor. You can see that the code creates a new T1 object and uses its CompareTo method (which is defined by IComparable).

The second constraint clause requires that the type T2 also provide a parameterless constructor. The code needs that because it also creates a new T2 instance.

In addition to building generic classes, you can also build generic methods inside either a generic class or a regular nongeneric class.

For example, suppose you want to rearrange the items in a list so the new order alternately picks items from each end of the list. If the list originally contains the numbers 1, 2, 3, 4, 5, 6, then the alternated list contains 1, 6, 2, 5, 3, 4.

The following code shows how a program could declare an Alternate function to return an alternated list. Note that you could put this function in any class, generic or not.

Public Function Alternate(Of T)(ByVal values As List(Of T)) As List(Of T)
    ' Make a new list to hold the results.
    Dim alternatedItems As New List(Of T)()
    ...
    Return alternatedItems
End Function

The Alternate function takes a generic type parameter T. It takes as a regular parameter a List that holds items of type T and it returns a new List containing items of type T.

This snippet creates a new List(Of T) to hold the results. (Note that it does not need to require the type T to have a default constructor because the code is creating a new List, not a new T.) The code then builds the new list (not shown here) and returns it.

The following code shows how a program might use this function:

Dim names As New List(Of String)(
    {"Ant", "Badger", "Cat", "Dog", "Eagle", "Frog"}
)
Dim alternatedNames As List(Of String) = Alternate(Of String)(names)

The first statement defines a List(Of String) and initializes it with the some strings.

The second statement calls Alternate(Of String) to create an alternated List(Of String). Notice how the code uses (Of String) to indicate the data type that Alternate will manipulate. (This is actually optional and the program will figure out which version of Alternate to use if you omit it. However, this makes the code more explicit and may catch a bug if you try to alternate a list containing something unexpected such as Person objects.)

Generic methods can be quite useful for the same reasons that generic classes are. They enable code reuse without the extra hassle of converting values to and from the nonspecific Object class. They also perform type checking, so in this example, the program cannot try to alternate a List(Of Integer) by calling Alternate(Of String).

In this Try It, you build a generic Randomize function that randomizes an array of objects of any type. To make it easy to add the function to any project, you define the function in a code module.