Útmutató: Általános típusok vizsgálata és példányosítása tükröződéssel

Cikk
03/30/2024

Az általános típusokkal kapcsolatos információk ugyanúgy lesznek lekértek, mint a többi típusra vonatkozó információk: az általános típust Type képviselő objektum vizsgálatával. Az alapvető különbség az, hogy egy általános típus az általános típusparamétereket képviselő objektumok listájával Type rendelkezik. A szakasz első eljárása az általános típusokat vizsgálja.

Létrehozhat egy Type objektumot, amely az általános típusdefiníció típusparamétereinek kötéstípus-argumentumai alapján egy létrehozott típust jelöl. A második eljárás ezt mutatja be.

Általános típus és típusparamétereinek vizsgálata

Szerezze be az Type általános típust képviselő példányt. A következő kódban a típus a C# typeof operátorral lesz lekért (GetType a Visual Basicben, typeid a Visual C++-ban). Type Az objektum lekérésének egyéb módjai az osztály témakörében Type olvashatók. Vegye figyelembe, hogy az eljárás többi részében a típus egy metódusparaméterben ttalálható.
```
Type^ d1 = Dictionary::typeid;
```
```
Type d1 = typeof(Dictionary<,>);
```
```
Dim d1 As Type = GetType(Dictionary(Of ,))
```

IsGenericType A tulajdonság segítségével meghatározhatja, hogy a típus általános-e, és a IsGenericTypeDefinition tulajdonság használatával állapítsa meg, hogy a típus általános típusdefiníció-e.

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)

Szerezze be az általános típusú argumentumokat tartalmazó tömböt a GetGenericArguments metódus használatával.

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

Type[] typeParameters = t.GetGenericArguments();

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

Minden típusargumentum esetében határozza meg, hogy egy típusparaméterről (például egy általános típusdefinícióban) vagy egy típusparaméterhez (például egy konstruktált típusban) megadott típusról van-e szó a IsGenericParameter tulajdonság használatával.

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

A típusrendszerben az általános típusparamétereket a szokásos típusokhoz hasonlóan egy példány Typejelöli. Az alábbi kód egy Type általános típusparamétert képviselő objektum nevét és paraméterpozícióját jeleníti meg. A paraméter pozíciója itt triviális információ; ez akkor érdekesebb, ha egy másik általános típus típusargumentumaként használt típusparamétert vizsgál.

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)

Egy általános típusparaméter alaptípus-kényszerének és felületi kényszereinek meghatározása a GetGenericParameterConstraints metódus használatával egyetlen tömb összes kényszerének lekéréséhez. A korlátozások nem garantáltan egy adott sorrendben vannak.

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 A tulajdonság segítségével felderítheti egy típusparaméter különleges korlátait, például azt, hogy referenciatípus legyen. A tulajdonság olyan értékeket is tartalmaz, amelyek a varianciát jelölik, amelyeket elfedhet az alábbi kódban látható módon.

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

GenericParameterAttributes sConstraints =
    tp.GenericParameterAttributes &
    GenericParameterAttributes.SpecialConstraintMask;

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

A speciális kényszerattribútumok a jelölők, és ugyanaz a jelző (GenericParameterAttributes.None) is, amely nem jelöl különleges kényszereket, szintén nem jelent kovarianciát vagy kovátria-eltérést. Így ezeknek a feltételeknek a teszteléséhez a megfelelő maszkot kell használnia. Ebben az esetben a speciális kényszerjelölők elkülönítésére használható 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

Általános típusú példány létrehozása

Az általános típus olyan, mint egy sablon. Csak akkor hozhat létre példányokat, ha valós típusokat ad meg az általános típusparaméterekhez. Ahhoz, hogy ezt futásidőben, tükröződés használatával végezze el, a metódusra MakeGenericType van szükség.

Type Szerezze be az általános típust képviselő objektumot. A következő kód két különböző módon kapja meg az általános típust Dictionary<TKey,TValue> : a Type.GetType(String) metódus túlterhelését egy típust leíró sztringgel, és a GetGenericTypeDefinition metódus meghívásával a létrehozott típuson Dictionary\<String, Example> (Dictionary(Of String, Example) a Visual Basicben). A MakeGenericType metódushoz általános típusdefiníció szükséges.

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

Típusargumentumok tömbjének létrehozása a típusparaméterek helyettesítéséhez. A tömbnek a megfelelő számú objektumot kell tartalmaznia Type a típusparaméter-listában megjelenő sorrendben. Ebben az esetben a kulcs (első típusú paraméter) típus String, és a szótár értékei egy nevesített Exampleosztály példányai.
```
array<Type^>^ typeArgs = {String::typeid, Example::typeid};
```
```
Type[] typeArgs = {typeof(string), typeof(Example)};
```
```
Dim typeArgs() As Type = _
    {GetType(String), GetType(Example)}
```

Hívja meg a metódust MakeGenericType , hogy a típusargumentumokat a típusparaméterekhez kösse, és hozza létre a típust.

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

Type constructed = d1.MakeGenericType(typeArgs);

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

A metódus túlterhelésével CreateInstance(Type) hozzon létre egy létrehozott típusú objektumot. Az alábbi kód az Example osztály két példányát tárolja az eredményként kapott Dictionary<String, Example> objektumban.
```
Object^ o = Activator::CreateInstance(constructed);
```
```
object o = Activator.CreateInstance(constructed);
```
```
Dim o As Object = Activator.CreateInstance(constructed)
```

Példa

Az alábbi példakód egy metódust DisplayGenericType határoz meg a kódban használt általános típusdefiníciók és létrehozott típusok vizsgálatára és azok adatainak megjelenítésére. A DisplayGenericType metódus bemutatja, hogyan használható a IsGenericType, IsGenericParameterés GenericParameterPosition a tulajdonságok és a GetGenericArguments metódus.

A példa egy DisplayGenericParameter általános típusparaméter vizsgálatára és annak korlátainak megjelenítésére szolgáló metódust is definiál.

A példakód számos teszttípust határoz meg, köztük egy általános típust, amely a típusparaméterek korlátait szemlélteti, és bemutatja, hogyan jeleníthetők meg ezekről a típusokról az információk.

A példa egy típust hoz létre az Dictionary<TKey,TValue> osztályból egy típusargumentumokból álló tömb létrehozásával és a metódus meghívásával MakeGenericType . A program összehasonlítja a Type létrehozott MakeGenericType objektumot a Type (Visual Basicben) beszerzett typeofGetType objektummal, amely azt mutatja, hogy azonosak. Hasonlóképpen, a program a GetGenericTypeDefinition metódus használatával szerzi be a létrehozott típus általános típusdefinícióját, és összehasonlítja azt az Type Dictionary<TKey,TValue> osztályt képviselő objektummal.

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

Megosztás a következőn keresztül:

Útmutató: Általános típusok vizsgálata és példányosítása tükröződéssel

Általános típus és típusparamétereinek vizsgálata

Általános típusú példány létrehozása

Példa

Lásd még

Visszajelzés

További források