操作说明：使用反射检查和实例化泛型类型

项目
04/01/2024

获取泛型类型信息的方式与获取其他类型信息的方式相同：检查表示泛型类型的 Type 对象。主要的差异在于，泛型类型具有表示其泛型类型参数的 Type 对象列表。本部分的第一个过程是检查泛型类型。

通过将类型实参绑定到泛型类型定义的类型形参，可以创建表示构造类型的 Type 对象。第二个过程对此进行了演示。

检查泛型类型及其类型参数

获取表示泛型类型的 Type 实例。在下面的代码中，使用 C# 的 typeof 运算符（在 Visual Basic 中为 GetType，在 Visual C++ 中为 typeid）获取类型。有关获取 Type 对象的其他方法，请参阅 Type 类主题。请注意，在余下的过程中，类型包含在名为 t 的方法参数中。
```
Type^ d1 = Dictionary::typeid;
```
```
Type d1 = typeof(Dictionary<,>);
```
```
Dim d1 As Type = GetType(Dictionary(Of ,))
```

使用 IsGenericType 属性确定类型是否为泛型，然后使用 IsGenericTypeDefinition 属性确定类型是否为泛型类型定义。

Console::WriteLine("   Is this a generic type? {0}",
    t->IsGenericType);
Console::WriteLine("   Is this a generic type definition? {0}",
    t->IsGenericTypeDefinition);

Console.WriteLine("   Is this a generic type? {0}",
    t.IsGenericType);
Console.WriteLine("   Is this a generic type definition? {0}",
    t.IsGenericTypeDefinition);

Console.WriteLine("   Is this a generic type? " _
    & t.IsGenericType)
Console.WriteLine("   Is this a generic type definition? " _
    & t.IsGenericTypeDefinition)

使用 GetGenericArguments 方法获取包含泛型类型参数的数组。

array<Type^>^ typeParameters = t->GetGenericArguments();

Type[] typeParameters = t.GetGenericArguments();

Dim typeParameters() As Type = t.GetGenericArguments()

对于每个类型实参，使用 IsGenericParameter 属性确定它是类型形参（例如，在泛型类型定义中），还是为类型形参指定的类型（例如，在构造类型中）。

Console::WriteLine("   List {0} type arguments:",
    typeParameters->Length);
for each( Type^ tParam in typeParameters )
{
    if (tParam->IsGenericParameter)
    {
        DisplayGenericParameter(tParam);
    }
    else
    {
        Console::WriteLine("      Type argument: {0}",
            tParam);
    }
}

Console.WriteLine("   List {0} type arguments:",
    typeParameters.Length);
foreach( Type tParam in typeParameters )
{
    if (tParam.IsGenericParameter)
    {
        DisplayGenericParameter(tParam);
    }
    else
    {
        Console.WriteLine("      Type argument: {0}",
            tParam);
    }
}

Console.WriteLine("   List {0} type arguments:", _
    typeParameters.Length)
For Each tParam As Type In typeParameters
    If tParam.IsGenericParameter Then
        DisplayGenericParameter(tParam)
    Else
        Console.WriteLine("      Type argument: {0}", _
            tParam)
    End If
Next

在类型系统中，和普通类型一样，泛型类型参数由 Type 实例表示。以下代码显示表示泛型类型参数的 Type 对象的名称和参数位置。此处，参数位置无足轻重；它在用户检查已用作其他泛型类型的类型实参的类型形参时更有价值。

static void DisplayGenericParameter(Type^ tp)
{
    Console::WriteLine("      Type parameter: {0} position {1}",
        tp->Name, tp->GenericParameterPosition);

private static void DisplayGenericParameter(Type tp)
{
    Console.WriteLine("      Type parameter: {0} position {1}",
        tp.Name, tp.GenericParameterPosition);

Private Shared Sub DisplayGenericParameter(ByVal tp As Type)
    Console.WriteLine("      Type parameter: {0} position {1}", _
        tp.Name, tp.GenericParameterPosition)

通过使用 GetGenericParameterConstraints 方法获取单个数组中的所有约束，确定泛型类型参数的基类型约束和接口约束。不保证约束以任何特定顺序排列。

Type^ classConstraint = nullptr;

for each(Type^ iConstraint in tp->GetGenericParameterConstraints())
{
    if (iConstraint->IsInterface)
    {
        Console::WriteLine("         Interface constraint: {0}",
            iConstraint);
    }
}

if (classConstraint != nullptr)
{
    Console::WriteLine("         Base type constraint: {0}",
        tp->BaseType);
}
else
    Console::WriteLine("         Base type constraint: None");

Type classConstraint = null;

foreach(Type iConstraint in tp.GetGenericParameterConstraints())
{
    if (iConstraint.IsInterface)
    {
        Console.WriteLine("         Interface constraint: {0}",
            iConstraint);
    }
}

if (classConstraint != null)
{
    Console.WriteLine("         Base type constraint: {0}",
        tp.BaseType);
}
else
{
    Console.WriteLine("         Base type constraint: None");
}

Dim classConstraint As Type = Nothing

For Each iConstraint As Type In tp.GetGenericParameterConstraints()
    If iConstraint.IsInterface Then
        Console.WriteLine("         Interface constraint: {0}", _
            iConstraint)
    End If
Next

If classConstraint IsNot Nothing Then
    Console.WriteLine("         Base type constraint: {0}", _
        tp.BaseType)
Else
    Console.WriteLine("         Base type constraint: None")
End If

使用 GenericParameterAttributes 属性发现类型参数的特殊约束，如要求其作为引用类型。该属性还包含表示方差的值，该值可屏蔽，如下面的代码所示。

GenericParameterAttributes sConstraints =
    tp->GenericParameterAttributes &
    GenericParameterAttributes::SpecialConstraintMask;

GenericParameterAttributes sConstraints =
    tp.GenericParameterAttributes &
    GenericParameterAttributes.SpecialConstraintMask;

Dim sConstraints As GenericParameterAttributes = _
    tp.GenericParameterAttributes And _
    GenericParameterAttributes.SpecialConstraintMask

特殊约束属性为标志，表示没有任何特殊约束的相同标志 (GenericParameterAttributes.None) 还表示没有协变或逆变。因此，若要测试其中一项条件，则必须使用适当的掩码。在这种情况下，请使用 GenericParameterAttributes.SpecialConstraintMask 隔离特殊约束标志。

if (sConstraints == GenericParameterAttributes::None)
{
    Console::WriteLine("         No special constraints.");
}
else
{
    if (GenericParameterAttributes::None != (sConstraints &
        GenericParameterAttributes::DefaultConstructorConstraint))
    {
        Console::WriteLine("         Must have a parameterless constructor.");
    }
    if (GenericParameterAttributes::None != (sConstraints &
        GenericParameterAttributes::ReferenceTypeConstraint))
    {
        Console::WriteLine("         Must be a reference type.");
    }
    if (GenericParameterAttributes::None != (sConstraints &
        GenericParameterAttributes::NotNullableValueTypeConstraint))
    {
        Console::WriteLine("         Must be a non-nullable value type.");
    }
}

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

If sConstraints = GenericParameterAttributes.None Then
    Console.WriteLine("         No special constraints.")
Else
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.DefaultConstructorConstraint) Then
        Console.WriteLine("         Must have a parameterless constructor.")
    End If
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.ReferenceTypeConstraint) Then
        Console.WriteLine("         Must be a reference type.")
    End If
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.NotNullableValueTypeConstraint) Then
        Console.WriteLine("         Must be a non-nullable value type.")
    End If
End If

构造泛型类型的实例

泛型类型和模板类似。除非指定其泛型类型参数的实际类型，否则不能创建泛型类型的实例。若要在运行时执行此操作，则需要使用 MakeGenericType 方法。

获取表示泛型类型的 Type 对象。以下代码以两种不同方式获取泛型类型 Dictionary<TKey,TValue>：一种是使用 Type.GetType(String) 方法重载和描述类型的字符串，另一种是调用构造类型 Dictionary\<String, Example>（在 Visual Basic 中为 Dictionary(Of String, Example)）的 GetGenericTypeDefinition 方法。 MakeGenericType 方法需要泛型类型定义。

// Use the typeid keyword to create the generic type
// definition directly.
Type^ d1 = Dictionary::typeid;

// 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 = gcnew 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();

// 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();

' 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()

构造用于替代类型形参的类型实参数组。该数组必须包含正确数目的 Type 对象，并且顺序和它们在类型形参列表中的顺序相同。在这种情况下，键（第一个类型形参）的类型为 String，字典中的值是名为 Example 的类的实例。
```
array<Type^>^ typeArgs = {String::typeid, Example::typeid};
```
```
Type[] typeArgs = {typeof(string), typeof(Example)};
```
```
Dim typeArgs() As Type = _
    {GetType(String), GetType(Example)}
```

调用 MakeGenericType 方法，将类型实参绑定到类型形参，然后构造类型。

Type^ constructed = d1->MakeGenericType(typeArgs);

Type constructed = d1.MakeGenericType(typeArgs);

Dim constructed As Type = _
    d1.MakeGenericType(typeArgs)

使用 CreateInstance(Type) 方法重载来创建构造类型的对象。以下代码在生成的 Dictionary<String, Example> 对象中存储 Example 类的两个实例。
```
Object^ o = Activator::CreateInstance(constructed);
```
```
object o = Activator.CreateInstance(constructed);
```
```
Dim o As Object = Activator.CreateInstance(constructed)
```

示例

下面的代码示例定义 DisplayGenericType 方法来检查代码中使用的泛型类型定义和构造类型，并显示它们的信息。 DisplayGenericType 方法演示如何使用 IsGenericType、IsGenericParameter 和 GenericParameterPosition 属性以及 GetGenericArguments 方法。

该示例还定义 DisplayGenericParameter 方法来检查泛型类型参数，并显示其约束。

代码示例定义一组测试类型，包括说明类型参数约束的泛型类型，并演示如何显示这些类型的信息。

示例通过创建类型参数数组并调用 MakeGenericType 方法，从 Dictionary<TKey,TValue> 类构造类型。程序将使用 MakeGenericType 构造的 Type 对象和使用 typeof（在 Visual Basic 中为 GetType）获取的 Type 对象进行比较，演示这两个对象是相同的。类似地，程序使用 GetGenericTypeDefinition 方法获取构造类型的泛型类型定义，并将其与表示 Dictionary<TKey,TValue> 类的 Type 对象进行比较。

using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;
using namespace System::Security::Permissions;

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

// Define an example base class.
public ref 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.

generic<class T>
    where T : TestBase, ITestArgument, gcnew()
public ref class Test {};

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

public ref class Example
{
    // The following method displays information about a generic
    // type.
private:
    static void DisplayGenericType(Type^ t)
    {
        Console::WriteLine("\r\n {0}", t);
        Console::WriteLine("   Is this a generic type? {0}",
            t->IsGenericType);
        Console::WriteLine("   Is this a generic type definition? {0}",
            t->IsGenericTypeDefinition);

        // Get the generic type parameters or type arguments.
        array<Type^>^ typeParameters = t->GetGenericArguments();

        Console::WriteLine("   List {0} type arguments:",
            typeParameters->Length);
        for each( Type^ tParam in typeParameters )
        {
            if (tParam->IsGenericParameter)
            {
                DisplayGenericParameter(tParam);
            }
            else
            {
                Console::WriteLine("      Type argument: {0}",
                    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.
    static void DisplayGenericParameter(Type^ tp)
    {
        Console::WriteLine("      Type parameter: {0} position {1}",
            tp->Name, tp->GenericParameterPosition);

        Type^ classConstraint = nullptr;

        for each(Type^ iConstraint in tp->GetGenericParameterConstraints())
        {
            if (iConstraint->IsInterface)
            {
                Console::WriteLine("         Interface constraint: {0}",
                    iConstraint);
            }
        }

        if (classConstraint != nullptr)
        {
            Console::WriteLine("         Base type constraint: {0}",
                tp->BaseType);
        }
        else
            Console::WriteLine("         Base type constraint: None");

        GenericParameterAttributes sConstraints =
            tp->GenericParameterAttributes &
            GenericParameterAttributes::SpecialConstraintMask;

        if (sConstraints == GenericParameterAttributes::None)
        {
            Console::WriteLine("         No special constraints.");
        }
        else
        {
            if (GenericParameterAttributes::None != (sConstraints &
                GenericParameterAttributes::DefaultConstructorConstraint))
            {
                Console::WriteLine("         Must have a parameterless constructor.");
            }
            if (GenericParameterAttributes::None != (sConstraints &
                GenericParameterAttributes::ReferenceTypeConstraint))
            {
                Console::WriteLine("         Must be a reference type.");
            }
            if (GenericParameterAttributes::None != (sConstraints &
                GenericParameterAttributes::NotNullableValueTypeConstraint))
            {
                Console::WriteLine("         Must be a non-nullable value type.");
            }
        }
    }

public:
    [PermissionSetAttribute(SecurityAction::Demand, Name="FullTrust")]
    static void Main()
    {
        // Two ways to get a Type object that represents the generic
        // type definition of the Dictionary class.
        //
        // Use the typeid keyword to create the generic type
        // definition directly.
        Type^ d1 = Dictionary::typeid;

        // 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 = gcnew 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.
        array<Type^>^ typeArgs = {String::typeid, Example::typeid};

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

        DisplayGenericType(constructed);

        Object^ o = Activator::CreateInstance(constructed);

        Console::WriteLine("\r\nCompare types obtained by different methods:");
        Console::WriteLine("   Are the constructed types equal? {0}",
            (d2->GetType()==constructed));
        Console::WriteLine("   Are the generic definitions equal? {0}",
            (d1==constructed->GetGenericTypeDefinition()));

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

int main()
{
    Example::Main();
}

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
{
    // The following method displays information about a generic
    // type.
    private static void DisplayGenericType(Type t)
    {
        Console.WriteLine("\r\n {0}", t);
        Console.WriteLine("   Is this a generic type? {0}",
            t.IsGenericType);
        Console.WriteLine("   Is this a generic type definition? {0}",
            t.IsGenericTypeDefinition);

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

        Console.WriteLine("   List {0} type arguments:",
            typeParameters.Length);
        foreach( Type tParam in typeParameters )
        {
            if (tParam.IsGenericParameter)
            {
                DisplayGenericParameter(tParam);
            }
            else
            {
                Console.WriteLine("      Type argument: {0}",
                    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)
    {
        Console.WriteLine("      Type parameter: {0} position {1}",
            tp.Name, tp.GenericParameterPosition);

        Type classConstraint = null;

        foreach(Type iConstraint in tp.GetGenericParameterConstraints())
        {
            if (iConstraint.IsInterface)
            {
                Console.WriteLine("         Interface constraint: {0}",
                    iConstraint);
            }
        }

        if (classConstraint != null)
        {
            Console.WriteLine("         Base type constraint: {0}",
                tp.BaseType);
        }
        else
        {
            Console.WriteLine("         Base type constraint: None");
        }

        GenericParameterAttributes sConstraints =
            tp.GenericParameterAttributes &
            GenericParameterAttributes.SpecialConstraintMask;

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

    public static void Main()
    {
        // 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);

        Console.WriteLine("\r\nCompare types obtained by different methods:");
        Console.WriteLine("   Are the constructed types equal? {0}",
            (d2.GetType()==constructed));
        Console.WriteLine("   Are the generic definitions equal? {0}",
            (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<>));
    }
}

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
    ' The following method displays information about a generic
    ' type.
    Private Shared Sub DisplayGenericType(ByVal t As Type)
        Console.WriteLine(vbCrLf & t.ToString())
        Console.WriteLine("   Is this a generic type? " _
            & t.IsGenericType)
        Console.WriteLine("   Is this a generic type definition? " _
            & t.IsGenericTypeDefinition)

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

        Console.WriteLine("   List {0} type arguments:", _
            typeParameters.Length)
        For Each tParam As Type In typeParameters
            If tParam.IsGenericParameter Then
                DisplayGenericParameter(tParam)
            Else
                Console.WriteLine("      Type argument: {0}", _
                    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)
        Console.WriteLine("      Type parameter: {0} position {1}", _
            tp.Name, tp.GenericParameterPosition)

        Dim classConstraint As Type = Nothing

        For Each iConstraint As Type In tp.GetGenericParameterConstraints()
            If iConstraint.IsInterface Then
                Console.WriteLine("         Interface constraint: {0}", _
                    iConstraint)
            End If
        Next

        If classConstraint IsNot Nothing Then
            Console.WriteLine("         Base type constraint: {0}", _
                tp.BaseType)
        Else
            Console.WriteLine("         Base type constraint: None")
        End If

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

    Public Shared Sub Main()
        ' 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)

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

        ' 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

操作说明：使用反射检查和实例化泛型类型

检查泛型类型及其类型参数

构造泛型类型的实例

示例

请参阅

反馈

其他资源