Type.GetGenericTypeDefinition Methode

Definition

Gibt ein Type-Objekt zurück, das eine generische Typdefinition darstellt, aus der der aktuelle generische Typ konstruiert werden kann.Returns a Type object that represents a generic type definition from which the current generic type can be constructed.

public:
 virtual Type ^ GetGenericTypeDefinition();
public virtual Type GetGenericTypeDefinition ();
abstract member GetGenericTypeDefinition : unit -> Type
override this.GetGenericTypeDefinition : unit -> Type
Public Overridable Function GetGenericTypeDefinition () As Type

Gibt zurück

Ein Type-Objekt, das einen generischen Typ darstellt, aus dem der aktuelle Typ konstruiert werden kann.A Type object representing a generic type from which the current type can be constructed.

Ausnahmen

Der aktuelle Typ ist kein generischer Typ.The current type is not a generic type. Das heißt, IsGenericType gibt false zurück.That is, IsGenericType returns false.

Die aufgerufene Methode wird in der Basisklasse nicht unterstützt.The invoked method is not supported in the base class. Abgeleitete Klassen müssen eine Implementation angeben.Derived classes must provide an implementation.

Beispiele

Im folgenden Codebeispiel wird eine Instanz eines konstruierten Typs mithilfe der Erstellung der normalen Instanz erstellt. Anschließend werden die Methoden GetType und GetGenericTypeDefinition verwendet, um den konstruierten Typ und die generische Typdefinition abzurufen.The following code example creates an instance of a constructed type by using ordinary instance creation and then uses the GetType and GetGenericTypeDefinition methods to retrieve the constructed type and the generic type definition. In diesem Beispiel wird der generische Dictionary<TKey,TValue>-Typ verwendet. der konstruierte Typ stellt eine Dictionary<TKey,TValue> von Test Objekten mit Zeichen folgen Schlüsseln dar.This example uses the generic Dictionary<TKey,TValue> type; the constructed type represents a Dictionary<TKey,TValue> of Test objects with string keys.

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

public ref class Test
{
public:
   static void Main()
   {
      Console::Write( L"\r\n--- Get the generic type that " );
      Console::WriteLine( L"defines a constructed type." );
     
      // Create a Dictionary of Test objects, using strings for the
      // keys.
      Dictionary< String^,Test^ >^ d = gcnew Dictionary< String^,Test^ >;
      
      // Get a Type object representing the constructed type.
      //
      Type^ constructed = d->GetType();
      DisplayTypeInfo( constructed );
      Type^ myGeneric = constructed->GetGenericTypeDefinition();
      DisplayTypeInfo( myGeneric );
   }

private:
   static void DisplayTypeInfo( Type^ t )
   {
      Console::WriteLine( L"\r\n{0}", t );
      Console::WriteLine( L"\tIs this a generic type definition? {0}",
         t->IsGenericTypeDefinition );
      Console::WriteLine( L"\tIs it a generic type? {0}",
         t->IsGenericType );
      array<Type^>^typeArguments = t->GetGenericArguments();
      Console::WriteLine( L"\tList type arguments ({0}):",
         typeArguments->Length );
      System::Collections::IEnumerator^ myEnum =
         typeArguments->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Type^ tParam = safe_cast<Type^>(myEnum->Current);
         Console::WriteLine( L"\t\t{0}", tParam );
      }
   }
};

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

/* This example produces the following output:

--- Get the generic type that defines a constructed type.

System.Collections.Generic.Dictionary`2[System.String,Test]
        Is this a generic type definition? False
        Is it a generic type? True
        List type arguments (2):
                System.String
                Test

System.Collections.Generic.Dictionary`2[TKey,TValue]
        Is this a generic type definition? True
        Is it a generic type? True
        List type arguments (2):
                TKey
                TValue
 */
using System;
using System.Reflection;
using System.Collections.Generic;

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Get the generic type that defines a constructed type.");

        // Create a Dictionary of Test objects, using strings for the
        // keys.       
        Dictionary<string, Test> d = new Dictionary<string, Test>();

        // Get a Type object representing the constructed type.
        //
        Type constructed = d.GetType();
        DisplayTypeInfo(constructed);

        Type generic = constructed.GetGenericTypeDefinition();
        DisplayTypeInfo(generic);
    }

    private static void DisplayTypeInfo(Type t)
    {
        Console.WriteLine("\r\n{0}", t);
        Console.WriteLine("\tIs this a generic type definition? {0}", 
            t.IsGenericTypeDefinition);
        Console.WriteLine("\tIs it a generic type? {0}", 
            t.IsGenericType);
        Type[] typeArguments = t.GetGenericArguments();
        Console.WriteLine("\tList type arguments ({0}):", typeArguments.Length);
        foreach (Type tParam in typeArguments)
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}

/* This example produces the following output:

--- Get the generic type that defines a constructed type.

System.Collections.Generic.Dictionary`2[System.String,Test]
        Is this a generic type definition? False
        Is it a generic type? True
        List type arguments (2):
                System.String
                Test

System.Collections.Generic.Dictionary`2[TKey,TValue]
        Is this a generic type definition? True
        Is it a generic type? True
        List type arguments (2):
                TKey
                TValue
 */
Imports System.Reflection
Imports System.Collections.Generic

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Get the generic type that defines a constructed type.")
        
        ' Create a Dictionary of Test objects, using strings for the
        ' keys.
        Dim d As New Dictionary(Of String, Test)
        
        ' Get a Type object representing the constructed type.
        '
        Dim constructed As Type = d.GetType()
        DisplayTypeInfo(constructed)
        
        Dim generic As Type = constructed.GetGenericTypeDefinition()
        DisplayTypeInfo(generic)
    End Sub
    
    Private Shared Sub DisplayTypeInfo(ByVal t As Type) 
        Console.WriteLine(vbCrLf & t.ToString())
        Console.WriteLine(vbTab & "Is this a generic type definition? " _
            & t.IsGenericTypeDefinition)
        Console.WriteLine(vbTab & "Is it a generic type? " _
            & t.IsGenericType)
        Dim typeArguments As Type() = t.GetGenericArguments()
        Console.WriteLine(vbTab & "List type arguments (" _
            & typeArguments.Length & "):")
        For Each tParam As Type In typeArguments
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        Next tParam
    End Sub
End Class

' This example produces the following output:
'
'--- Get the generic type that defines a constructed type.
'
'System.Collections.Generic.Dictionary`2[System.String,Test]
'        Is this a generic type definition? False
'        Is it a generic type? True
'        List type arguments (2):
'                System.String
'                Test
'
'System.Collections.Generic.Dictionary`2[TKey,TValue]
'        Is this a generic type definition? True
'        Is it a generic type? True
'        List type arguments (2):
'                TKey
'                TValue
' 

Hinweise

Eine generische Typdefinition ist eine Vorlage, von der andere Typen erstellt werden können.A generic type definition is a template from which other types can be constructed. Beispielsweise können Sie aus der generischen Typdefinition G<T> ( C# ausgedrückt in Syntax, G(Of T) in Visual Basic oder C++generic <typename T> ref class G in) den Typ G<int> (G(Of Integer) in Visual Basic) erstellen und instanziieren.For example, from the generic type definition G<T> (expressed in C# syntax; G(Of T) in Visual Basic or generic <typename T> ref class G in C++) you can construct and instantiate the type G<int> (G(Of Integer) in Visual Basic). Bei einem Type Objekt, das diesen konstruierten Typ darstellt, gibt die GetGenericTypeDefinition-Methode die generische Typdefinition zurück.Given a Type object representing this constructed type, the GetGenericTypeDefinition method returns the generic type definition.

Wenn zwei konstruierte Typen aus der gleichen generischen Typdefinition erstellt werden, wobei die gleichen Typargumente verwendet werden, gibt die GetGenericTypeDefinition-Methode für beide Typen dasselbe Type-Objekt zurück.If two constructed types are created from the same generic type definition, using the same type arguments, the GetGenericTypeDefinition method returns the same Type object for both types.

Wenn Sie die GetGenericTypeDefinition-Methode für ein Type Objekt aufzurufen, das bereits eine generische Typdefinition darstellt, wird die aktuelle Typezurückgegeben.If you call the GetGenericTypeDefinition method on a Type object that already represents a generic type definition, it returns the current Type.

Wichtig

Ein Array generischer Typen ist nicht selbst generisch.An array of generic types is not itself generic. Im C# Code A<int>[] v; oder im Visual Basic Code Dim v() As A(Of Integer)ist der Typ der Variablen v nicht generisch.In the C# code A<int>[] v; or the Visual Basic code Dim v() As A(Of Integer), the type of variable v is not generic. Verwenden Sie IsGenericType, um zu bestimmen, ob ein Typ generisch ist, bevor Sie GetGenericTypeDefinitionaufrufenUse IsGenericType to determine whether a type is generic before calling GetGenericTypeDefinition.

Eine Liste der invarianten Bedingungen für Begriffe, für Begriffe, die für die Reflektion mit generischen Methoden verwendet werden, finden Sie in den Hinweisen zur Eigenschaft IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Gilt für:

Siehe auch