How to: Examine and Instantiate Generic Types with Reflection

Imports System
Imports System.Reflection
Imports System.Collections.Generic

' Define an example interface.
Public Interface ITestArgument
End Interface

' Define an example base class.
Public Class TestBase
End Class

' Define a generic class with one parameter. The parameter
' has three constraints: It must inherit TestBase, it must
' implement ITestArgument, and it must have a parameterless
' constructor.
Public Class Test(Of T As {TestBase, ITestArgument, New})
End Class

' Define a class that meets the constraints on the type
' parameter of class Test.
Public Class TestArgument
    Inherits TestBase
    Implements ITestArgument
    Public Sub New()
    End Sub
End Class

Public Class Example

    ' Makes the TextBlock available to all methods in Example.
    Private Shared output As System.Windows.Controls.TextBlock

    ' The following method displays information about a generic
    ' type.
    Private Shared Sub DisplayGenericType(ByVal t As Type)
        output.Text &= vbCrLf & t.ToString() & vbCrLf
        output.Text &= "   Is this a generic type? " _ 
            & t.IsGenericType & vbCrLf
        output.Text &= "   Is this a generic type definition? " _ 
            & t.IsGenericTypeDefinition & vbCrLf

        ' Get the generic type parameters or type arguments.
        Dim typeParameters() As Type = t.GetGenericArguments()

        output.Text &= String.Format("   List {0} type arguments:" & vbCrLf, _
            typeParameters.Length)
        For Each tParam As Type In typeParameters
            If tParam.IsGenericParameter Then
                DisplayGenericParameter(tParam)
            Else
                output.Text &= String.Format("      Type argument: {0}" & vbCrLf, _
                    tParam)
            End If
        Next
    End Sub

    ' The following method displays information about a generic
    ' type parameter. Generic type parameters are represented by
    ' instances of System.Type, just like ordinary types.
    Private Shared Sub DisplayGenericParameter(ByVal tp As Type)
        output.Text &= String.Format("      Type parameter: {0} position {1}" & vbCrLf, _
            tp.Name, tp.GenericParameterPosition)

        Dim classConstraint As Type = Nothing

        For Each iConstraint As Type In tp.GetGenericParameterConstraints()
            If iConstraint.IsInterface Then
                output.Text &= String.Format("         Interface constraint: {0}" & vbCrLf, _
                    iConstraint)
            End If
        Next

        If classConstraint IsNot Nothing Then
            output.Text &= String.Format("         Base type constraint: {0}" & vbCrLf, _
                tp.BaseType)
        Else
            output.Text &= "         Base type constraint: None" & vbCrLf
        End If

        Dim sConstraints As GenericParameterAttributes = _
            tp.GenericParameterAttributes And _
            GenericParameterAttributes.SpecialConstraintMask
        If sConstraints = GenericParameterAttributes.None Then
            output.Text &= "         No special constraints." & vbCrLf
        Else
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.DefaultConstructorConstraint) Then
                output.Text &= "         Must have a parameterless constructor." & vbCrLf
            End If
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.ReferenceTypeConstraint) Then
                output.Text &= "         Must be a reference type." & vbCrLf
            End If
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.NotNullableValueTypeConstraint) Then
                output.Text &= "         Must be a non-nullable value type." & vbCrLf
            End If
        End If
    End Sub

    Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

        ' Makes the TextBlock available to all methods in Example.
        output = outputBlock

        ' Two ways to get a Type object that represents the generic
        ' type definition of the Dictionary class. 
        '
        ' Use the GetType operator to create the generic type 
        ' definition directly. To specify the generic type definition,
        ' omit the type arguments but retain the comma that separates
        ' them.
        Dim d1 As Type = GetType(Dictionary(Of ,))

        ' You can also obtain the generic type definition from a
        ' constructed class. In this case, the constructed class
        ' is a dictionary of Example objects, with String keys.
        Dim d2 As New Dictionary(Of String, Example)
        ' Get a Type object that represents the constructed type,
        ' and from that get the generic type definition. The 
        ' variables d1 and d4 contain the same type.
        Dim d3 As Type = d2.GetType()
        Dim d4 As Type = d3.GetGenericTypeDefinition()

        ' Display information for the generic type definition, and
        ' for the constructed type Dictionary(Of String, Example).
        DisplayGenericType(d1)
        DisplayGenericType(d2.GetType())

        ' Construct an array of type arguments to substitute for 
        ' the type parameters of the generic Dictionary class.
        ' The array must contain the correct number of types, in 
        ' the same order that they appear in the type parameter 
        ' list of Dictionary. The key (first type parameter)
        ' is of type string, and the type to be contained in the
        ' dictionary is Example.
        Dim typeArgs() As Type = _
            { GetType(String), GetType(Example) }

        ' Construct the type Dictionary(Of String, Example).
        Dim constructed As Type = _
            d1.MakeGenericType(typeArgs)

        DisplayGenericType(constructed)

        Dim o As Object = Activator.CreateInstance(constructed)

        output.Text &= vbCrLf & _
            "Compare types obtained by different methods:" & vbCrLf
        output.Text &= "   Are the constructed types equal? " _
            & (d2.GetType() Is constructed) & vbCrLf
        output.Text &= "   Are the generic definitions equal? " _ 
            & (d1 Is constructed.GetGenericTypeDefinition()) & vbCrLf

        ' Demonstrate the DisplayGenericType and 
        ' DisplayGenericParameter methods with the Test class 
        ' defined above. This shows base, interface, and special
        ' constraints.
        DisplayGenericType(GetType(Test(Of )))
    End Sub
End Class

' This example produces output similar to the following:
'
'System.Collections.Generic.Dictionary`2[TKey,TValue]
'   Is this a generic type? True
'   Is this a generic type definition? True
'   List 2 type arguments:
'      Type parameter: TKey position 0
'         Base type constraint: None
'         No special constraints.
'      Type parameter: TValue position 1
'         Base type constraint: None
'         No special constraints.
'
'System.Collections.Generic.Dictionary`2[System.String,SilverlightApplication.Example]
'   Is this a generic type? True
'   Is this a generic type definition? False
'   List 2 type arguments:
'      Type argument: System.String
'      Type argument: SilverlightApplication.Example
'
'System.Collections.Generic.Dictionary`2[System.String,SilverlightApplication.Example]
'   Is this a generic type? True
'   Is this a generic type definition? False
'   List 2 type arguments:
'      Type argument: System.String
'      Type argument: SilverlightApplication.Example
'
'Compare types obtained by different methods:
'   Are the constructed types equal? True
'   Are the generic definitions equal? True
'
'Test`1[T]
'   Is this a generic type? True
'   Is this a generic type definition? True
'   List 1 type arguments:
'      Type parameter: T position 0
'         Interface constraint: SilverlightApplication.ITestArgument
'         Base type constraint: None
'         Must have a parameterless constructor.

using System;
using System.Reflection;
using System.Collections.Generic;

// Define an example interface.
public interface ITestArgument {}

// Define an example base class.
public class TestBase {}

// Define a generic class with one parameter. The parameter
// has three constraints: It must inherit TestBase, it must
// implement ITestArgument, and it must have a parameterless
// constructor.
public class Test<T> where T : TestBase, ITestArgument, new() {}

// Define a class that meets the constraints on the type
// parameter of class Test.
public class TestArgument : TestBase, ITestArgument
{
    public TestArgument() {}
}

public class Example
{
    // Makes the TextBlock available to all methods in Example.
    private static System.Windows.Controls.TextBlock output;

    // The following method displays information about a generic
    // type.
    private static void DisplayGenericType(Type t)
    {
        output.Text += String.Format("\r\n{0}\r\n", t);
        output.Text += String.Format("   Is this a generic type? {0}\r\n",
            t.IsGenericType);
        output.Text += String.Format("   Is this a generic type definition? {0}\r\n",
            t.IsGenericTypeDefinition);

        // Get the generic type parameters or type arguments.
        Type[] typeParameters = t.GetGenericArguments();

        output.Text += String.Format("   List {0} type arguments:\r\n", 
            typeParameters.Length);
        foreach( Type tParam in typeParameters )
        {
            if (tParam.IsGenericParameter)
            {
                DisplayGenericParameter(tParam);
            }
            else
            {
                output.Text += String.Format("      Type argument: {0}\r\n",
                    tParam);
            }
        }
    }

    // The following method displays information about a generic
    // type parameter. Generic type parameters are represented by
    // instances of System.Type, just like ordinary types.
    private static void DisplayGenericParameter(Type tp)
    {
        output.Text += String.Format("      Type parameter: {0} position {1}\r\n", 
            tp.Name, tp.GenericParameterPosition);

        Type classConstraint = null;

        foreach(Type iConstraint in tp.GetGenericParameterConstraints())
        {
            if (iConstraint.IsInterface)
            {
                output.Text += String.Format("         Interface constraint: {0}\r\n",
                    iConstraint);
            }
        }

        if (classConstraint != null)
        {
            output.Text += String.Format("         Base type constraint: {0}\r\n", 
                tp.BaseType);
        }
        else
            output.Text += "         Base type constraint: None\r\n"; 

        GenericParameterAttributes sConstraints = 
            tp.GenericParameterAttributes & 
            GenericParameterAttributes.SpecialConstraintMask;

        if (sConstraints == GenericParameterAttributes.None)
        {
            output.Text += "         No special constraints.\r\n";
        }
        else
        {
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.DefaultConstructorConstraint))
            {
                output.Text += "         Must have a parameterless constructor.\r\n";
            }
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.ReferenceTypeConstraint))
            {
                output.Text += "         Must be a reference type.\r\n";
            }
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.NotNullableValueTypeConstraint))
            {
                output.Text += "         Must be a non-nullable value type.\r\n";
            }
        }
    }

    public static void Demo(System.Windows.Controls.TextBlock outputBlock)
    {
        // Makes the TextBlock available to all methods in Example.
        output = outputBlock; 

        // Two ways to get a Type object that represents the generic
        // type definition of the Dictionary class. 
        //
        // Use the typeof operator to create the generic type 
        // definition directly. To specify the generic type definition,
        // omit the type arguments but retain the comma that separates
        // them.
        Type d1 = typeof(Dictionary<,>);

        // You can also obtain the generic type definition from a
        // constructed class. In this case, the constructed class
        // is a dictionary of Example objects, with String keys.
        Dictionary<string, Example> d2 = new Dictionary<string, Example>();
        // Get a Type object that represents the constructed type,
        // and from that get the generic type definition. The 
        // variables d1 and d4 contain the same type.
        Type d3 = d2.GetType();
        Type d4 = d3.GetGenericTypeDefinition();

        // Display information for the generic type definition, and
        // for the constructed type Dictionary<String, Example>.
        DisplayGenericType(d1);
        DisplayGenericType(d2.GetType());

        // Construct an array of type arguments to substitute for 
        // the type parameters of the generic Dictionary class.
        // The array must contain the correct number of types, in 
        // the same order that they appear in the type parameter 
        // list of Dictionary. The key (first type parameter)
        // is of type string, and the type to be contained in the
        // dictionary is Example.
        Type[] typeArgs = {typeof(string), typeof(Example)};

        // Construct the type Dictionary<String, Example>.
        Type constructed = d1.MakeGenericType(typeArgs);

        DisplayGenericType(constructed);

        object o = Activator.CreateInstance(constructed);

        output.Text += "\r\nCompare types obtained by different methods:\r\n";
        output.Text += String.Format("   Are the constructed types equal? {0}\r\n",
            (d2.GetType()==constructed));
        output.Text += String.Format("   Are the generic definitions equal? {0}\r\n",
            (d1==constructed.GetGenericTypeDefinition()));

        // Demonstrate the DisplayGenericType and 
        // DisplayGenericParameter methods with the Test class 
        // defined above. This shows base, interface, and special
        // constraints.
        DisplayGenericType(typeof(Test<>));
    }
}

/* This example produces the following output:

System.Collections.Generic.Dictionary`2[TKey,TValue]
   Is this a generic type? True
   Is this a generic type definition? True
   List 2 type arguments:
      Type parameter: TKey position 0
         Base type constraint: None
         No special constraints.
      Type parameter: TValue position 1
         Base type constraint: None
         No special constraints.

System.Collections.Generic.Dictionary`2[System.String,Example]
   Is this a generic type? True
   Is this a generic type definition? False
   List 2 type arguments:
      Type argument: System.String
      Type argument: Example

System.Collections.Generic.Dictionary`2[System.String,Example]
   Is this a generic type? True
   Is this a generic type definition? False
   List 2 type arguments:
      Type argument: System.String
      Type argument: Example

Compare types obtained by different methods:
   Are the constructed types equal? True
   Are the generic definitions equal? True

Test`1[T]
   Is this a generic type? True
   Is this a generic type definition? True
   List 1 type arguments:
      Type parameter: T position 0
         Interface constraint: ITestArgument
         Base type constraint: None
         Must have a parameterless constructor.
 */