Type.IsGenericType Eigenschaft

Definition

Ruft einen Wert ab, der angibt, ob der aktuelle Typ ein generischer Typ ist.

public:
 virtual property bool IsGenericType { bool get(); };
public virtual bool IsGenericType { get; }
member this.IsGenericType : bool
Public Overridable ReadOnly Property IsGenericType As Boolean

Eigenschaftswert

Boolean

true wenn der aktuelle Typ ein generischer Typ ist; falseandernfalls .

Beispiele

Im folgenden Codebeispiel wird der Wert der IsGenericTypeIsGenericTypeDefinitionIsGenericParameterContainsGenericParameters im Abschnitt "Hinweise" beschriebenen Typen angezeigt. Erläuterungen zu den Eigenschaftenwerten finden Sie in der zugehörigen Tabelle in den Anmerkungen.

using namespace System;
using namespace System::Reflection;

generic<typename T, typename U> public ref class Base {};

generic<typename T> public ref class G {};

generic<typename V> public ref class Derived : Base<String^, V>
{
public: 
    G<Derived<V>^>^ F;

    ref class Nested {};
};

void DisplayGenericType(Type^ t, String^ caption)
{
    Console::WriteLine("\n{0}", caption);
    Console::WriteLine("    Type: {0}", t);

    Console::WriteLine("\t            IsGenericType: {0}", 
        t->IsGenericType);
    Console::WriteLine("\t  IsGenericTypeDefinition: {0}", 
        t->IsGenericTypeDefinition);
    Console::WriteLine("\tContainsGenericParameters: {0}", 
        t->ContainsGenericParameters);
    Console::WriteLine("\t       IsGenericParameter: {0}", 
        t->IsGenericParameter);
}

void main()
{
    // Get the generic type definition for Derived, and the base
    // type for Derived.
    //
    Type^ tDerived = Derived::typeid;
    Type^ tDerivedBase = tDerived->BaseType;

    // Declare an array of Derived<int>, and get its type.
    //
    array<Derived<int>^>^ d = gcnew array<Derived<int>^>(0);
    Type^ tDerivedArray = d->GetType();

    // Get a generic type parameter, the type of a field, and a
    // type that is nested in Derived. Notice that in order to
    // get the nested type it is necessary to either (1) specify
    // the generic type definition Derived::typeid, as shown here,
    // or (2) specify a type parameter for Derived.
    //
    Type^ tT = Base::typeid->GetGenericArguments()[0];
    Type^ tF = tDerived->GetField("F")->FieldType;
    Type^ tNested = Derived::Nested::typeid;

    DisplayGenericType(tDerived, "generic<V> Derived");
    DisplayGenericType(tDerivedBase, "Base type of generic<V> Derived");
    DisplayGenericType(tDerivedArray, "Array of Derived<int>");
    DisplayGenericType(tT, "Type parameter T from generic<T> Base");
    DisplayGenericType(tF, "Field type, G<Derived<V>^>^");
    DisplayGenericType(tNested, "Nested type in generic<V> Derived");
}

/* This code example produces the following output:

generic<V> Derived
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of generic<V> Derived
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from generic<T> Base
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>^>^
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in generic<V> Derived
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */
using System;
using System.Reflection;

public class Base<T, U> {}

public class Derived<V> : Base<string, V>
{
    public G<Derived <V>> F;

    public class Nested {}
}

public class G<T> {}

class Example
{
    public static void Main()
    {
        // Get the generic type definition for Derived, and the base
        // type for Derived.
        //
        Type tDerived = typeof(Derived<>);
        Type tDerivedBase = tDerived.BaseType;

        // Declare an array of Derived<int>, and get its type.
        //
        Derived<int>[] d = new Derived<int>[0];
        Type tDerivedArray = d.GetType();

        // Get a generic type parameter, the type of a field, and a
        // type that is nested in Derived. Notice that in order to
        // get the nested type it is necessary to either (1) specify
        // the generic type definition Derived<>, as shown here,
        // or (2) specify a type parameter for Derived.
        //
        Type tT = typeof(Base<,>).GetGenericArguments()[0];
        Type tF = tDerived.GetField("F").FieldType;
        Type tNested = typeof(Derived<>.Nested);

        DisplayGenericType(tDerived, "Derived<V>");
        DisplayGenericType(tDerivedBase, "Base type of Derived<V>");
        DisplayGenericType(tDerivedArray, "Array of Derived<int>");
        DisplayGenericType(tT, "Type parameter T from Base<T>");
        DisplayGenericType(tF, "Field type, G<Derived<V>>");
        DisplayGenericType(tNested, "Nested type in Derived<V>");
    }

    public static void DisplayGenericType(Type t, string caption)
    {
        Console.WriteLine("\n{0}", caption);
        Console.WriteLine("    Type: {0}", t);

        Console.WriteLine("\t            IsGenericType: {0}", 
            t.IsGenericType);
        Console.WriteLine("\t  IsGenericTypeDefinition: {0}", 
            t.IsGenericTypeDefinition);
        Console.WriteLine("\tContainsGenericParameters: {0}", 
            t.ContainsGenericParameters);
        Console.WriteLine("\t       IsGenericParameter: {0}", 
            t.IsGenericParameter);
    }
}

/* This code example produces the following output:

Derived<V>
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of Derived<V>
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from Base<T>
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>>
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in Derived<V>
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */
open System

type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>

let displayGenericType (t: Type) caption =
    printfn $"\n{caption}"
    printfn $"    Type: {t}"

    printfn $"\t            IsGenericType: {t.IsGenericType}" 
    printfn $"\t  IsGenericTypeDefinition: {t.IsGenericTypeDefinition}" 
    printfn $"\tContainsGenericParameters: {t.ContainsGenericParameters}"
    printfn $"\t       IsGenericParameter: {t.IsGenericParameter}"

// Get the generic type definition for Derived, and the base
// type for Derived.
let tDerived = typeof<Derived<_>>.GetGenericTypeDefinition()
let tDerivedBase = tDerived.BaseType

// Declare an array of Derived<int>, and get its type.
let d = Array.zeroCreate<Derived<int>> 0
let tDerivedArray = d.GetType()

// Get a generic type parameter, the type of a field, and a
// type that is nested in Derived. Notice that in order to
// get the nested type it is necessary to either (1) specify
// the generic type definition Derived<>, as shown here,
// or (2) specify a type parameter for Derived.
let tT = typeof<Base<_,_>>.GetGenericTypeDefinition().GetGenericArguments()[0]
let tF = tDerived.GetField("F").FieldType

displayGenericType tDerived "Derived<V>"
displayGenericType tDerivedBase "Base type of Derived<V>"
displayGenericType tDerivedArray "Array of Derived<int>"
displayGenericType tT "Type parameter T from Base<T>"
displayGenericType tF "Field type, G<Derived<V>>"

(* This code example produces the following output:

Derived<V>
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of Derived<V>
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from Base<T>
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>>
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False
 *)
Imports System.Reflection

' 
Public Class Base(Of T, U)
End Class

Public Class Derived(Of V) 
    Inherits Base(Of String, V)

    Public F As G(Of Derived(Of V))

    Public Class Nested
    End Class
End Class

Public Class G(Of T)
End Class 

Module Example

    Sub Main

        ' Get the generic type definition for Derived, and the base
        ' type for Derived.
        '
        Dim tDerived As Type = GetType(Derived(Of ))
        Dim tDerivedBase As Type = tDerived.BaseType

        ' Declare an array of Derived(Of Integer), and get its type.
        '
        Dim d(0) As Derived(Of Integer)
        Dim tDerivedArray As Type = d.GetType()

        ' Get a generic type parameter, the type of a field, and a
        ' type that is nested in Derived. Notice that in order to
        ' get the nested type it is necessary to either (1) specify
        ' the generic type definition Derived(Of ), as shown here,
        ' or (2) specify a type parameter for Derived.
        '
        Dim tT As Type = GetType(Base(Of ,)).GetGenericArguments()(0)
        Dim tF As Type = tDerived.GetField("F").FieldType
        Dim tNested As Type = GetType(Derived(Of ).Nested)

        DisplayGenericType(tDerived, "Derived(Of V)")
        DisplayGenericType(tDerivedBase, "Base type of Derived(Of V)")
        DisplayGenericType(tDerivedArray, "Array of Derived(Of Integer)")
        DisplayGenericType(tT, "Type parameter T from Base(Of T)")
        DisplayGenericType(tF, "Field type, G(Of Derived(Of V))")
        DisplayGenericType(tNested, "Nested type in Derived(Of V)")

    End Sub

    Sub DisplayGenericType(ByVal t As Type, ByVal caption As String)

        Console.WriteLine(vbLf & caption)
        Console.WriteLine("    Type: {0}", t)

        Console.WriteLine(vbTab & "            IsGenericType: {0}", _
            t.IsGenericType)
        Console.WriteLine(vbTab & "  IsGenericTypeDefinition: {0}", _
            t.IsGenericTypeDefinition)
        Console.WriteLine(vbTab & "ContainsGenericParameters: {0}", _
            t.ContainsGenericParameters)
        Console.WriteLine(vbTab & "       IsGenericParameter: {0}", _
            t.IsGenericParameter)

    End Sub

End Module

' This code example produces the following output:
'
'Derived(Of V)
'    Type: Derived`1[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Base type of Derived(Of V)
'    Type: Base`2[System.String,V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Array of Derived(Of Integer)
'    Type: Derived`1[System.Int32][]
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: False
'               IsGenericParameter: False
'
'Type parameter T from Base(Of T)
'    Type: T
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: True
'
'Field type, G(Of Derived(Of V))
'    Type: G`1[Derived`1[V]]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Nested type in Derived(Of V)
'    Type: Derived`1+Nested[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False

Hinweise

Verwenden Sie die IsGenericType Eigenschaft, um zu bestimmen, ob ein Type Objekt einen generischen Typ darstellt. Verwenden Sie die ContainsGenericParameters Eigenschaft, um zu bestimmen, ob ein Type Objekt einen geöffneten konstruierten Typ oder einen geschlossenen konstruierten Typ darstellt.

Hinweis

Die IsGenericType Eigenschaft gibt zurück false , wenn der direkte Typ nicht generisch ist. Beispielsweise ist ein Array, dessen Elemente vom Typ A<int> (A(Of Integer)in Visual Basic) nicht selbst ein generischer Typ sind.

In der folgenden Tabelle werden die invarianten Bedingungen für allgemeine Ausdrücke zusammengefasst, die in generischer Reflexion verwendet werden.

Begriff Invariante
generische Typdefinition Die IsGenericTypeDefinition-Eigenschaft ist true.

Definiert einen generischen Typ. Ein konstruierter Typ wird erstellt, indem die MakeGenericType Methode für ein Type Objekt aufgerufen wird, das eine generische Typdefinition darstellt und ein Array von Typargumenten angibt.

MakeGenericType kann nur für generische Typdefinitionen aufgerufen werden.

Jede generische Typdefinition ist ein generischer Typ (die IsGenericType Eigenschaft ist true), aber das Umgekehrte ist nicht wahr.
generischer Typ Die IsGenericType-Eigenschaft ist true.

Kann eine generische Typdefinition, ein geöffneter konstruierter Typ oder ein geschlossener konstruierter Typ sein.

Beachten Sie, dass ein Arraytyp, dessen Elementtyp generisch ist, nicht selbst ein generischer Typ ist. Dasselbe gilt für ein Type Objekt, das einen Zeiger auf einen generischen Typ darstellt.
geöffneter typ Die ContainsGenericParameters-Eigenschaft ist true.

Beispiele sind ein generischer Typ mit nicht zugewiesenen Typparametern, einem Typ, der in einer generischen Typdefinition oder in einem geöffneten konstruierten Typ oder einem generischen Typ mit einem Typargument ContainsGenericParameters truegeschachtelt ist.

Es ist nicht möglich, eine Instanz eines geöffneten konstruierten Typs zu erstellen.

Beachten Sie, dass nicht alle geöffneten konstruierten Typen generisch sind. Beispielsweise ist ein Array, dessen Elementtyp eine generische Typdefinition ist, nicht generisch, und ein Zeiger auf einen geöffneten konstruierten Typ ist nicht generisch.
geschlossener gebauter Typ Die ContainsGenericParameters-Eigenschaft ist false.

Wenn sie rekursiv untersucht werden, weist der Typ keine nicht zugewiesenen generischen Parameter auf.
generischer Typparameter Die IsGenericParameter-Eigenschaft ist true.

Die ContainsGenericParameters-Eigenschaft ist true.

In einer generischen Typdefinition wird später ein Platzhalter für einen Typ zugewiesen.
generisches Typargument Kann ein beliebiger Typ sein, einschließlich eines generischen Typparameters.

Typargumente werden als Array von Type Objekten angegeben, die beim Erstellen eines konstruierten generischen Typs an die MakeGenericType Methode übergeben werden. Wenn Instanzen des resultierenden Typs erstellt werden sollen, muss false die ContainsGenericParameters Eigenschaft für alle Typargumente gelten.

Das folgende Codebeispiel und die folgende Tabelle veranschaulichen einige dieser Begriffe und Invarianten. Die Derived Klasse ist besonders interessant, da der Basistyp ein konstruierter Typ ist, der eine Mischung aus Typen und Typparametern in der Typargumentliste enthält.

generic<typename T, typename U> public ref class Base {};

generic<typename T> public ref class G {};

generic<typename V> public ref class Derived : Base<String^, V>
{
public:
    G<Derived<V>^>^ F;

    ref class Nested {};
};
public class Base<T, U> {}

public class Derived<V> : Base<string, V>
{
    public G<Derived <V>> F;

    public class Nested {}
}

public class G<T> {}
type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>
Public Class Base(Of T, U)
End Class

Public Class Derived(Of V)
    Inherits Base(Of String, V)

    Public F As G(Of Derived(Of V))

    Public Class Nested
    End Class
End Class

Public Class G(Of T)
End Class

In der folgenden Tabelle sind Beispiele aufgeführt, die die Klassen , Derivedund die Klassen Baseverwenden und erstellen.G Wenn der C++- und C#-Code identisch ist, wird nur ein Eintrag angezeigt.

Beispiel Invarianten
Derived(Of V)

Derived<V>
Für diesen Typ:

IsGenericType ist true.

IsGenericTypeDefinition ist true.

ContainsGenericParameters ist true.
Base(Of String, V)

Base<String,V>

Base<String^,V>
Für diesen Typ:

IsGenericType ist true.

IsGenericTypeDefinition ist false.

ContainsGenericParameters ist true.
Dim d() As Derived(Of Integer)

Derived<int>[] d;

array<Derived<int>^>^ d;
Für den Typ der Variablen d:

IsGenericType liegt false daran, dass d es sich um ein Array handelt.

IsGenericTypeDefinition ist false.

ContainsGenericParameters ist false.
T, Uund V (überall dort, wo sie erscheinen) IsGenericParameter ist true.

IsGenericType liegt false daran, dass es keine Möglichkeit gibt, einen Typparameter auf generische Typen zu beschränken.

IsGenericTypeDefinition ist false.

ContainsGenericParameters liegt daran true , dass T, Uund V selbst generische Typparameter sind. Dies impliziert nichts über Typargumente, die ihnen später zugewiesen werden.
Der Feldtyp F IsGenericType ist true.

IsGenericTypeDefinition liegt false daran, dass einem Typ der Typparameter von G. Beachten Sie, dass dies dem Aufrufen der MakeGenericType Methode entspricht.

ContainsGenericParameters liegt true daran, dass der Feldtyp F ein Typargument hat, das ein geöffneter konstruierter Typ ist. Der konstruierte Typ ist geöffnet, da es sich bei dem Typargument (also um Baseeine generische Typdefinition) handelt. Dies veranschaulicht die rekursive Natur der IsGenericType Eigenschaft.
Die geschachtelte Klasse Nested IsGenericType ist true, auch wenn die Nested Klasse keine generischen Typparameter besitzt, da sie in einem generischen Typ geschachtelt ist.

IsGenericTypeDefinition ist true. Das heißt, Sie können die MakeGenericType Methode aufrufen und den Typparameter des eingeschlossenen Typs angeben, Derived.

ContainsGenericParameters liegt true daran, dass der eingeschlossene Typ über Derivedgenerische Typparameter verfügt. Dies veranschaulicht die rekursive Natur der ContainsGenericParameters Eigenschaft.

Gilt für:

Siehe auch