Type.IsGenericType Eigenschaft

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: Type.cs

Quelle:: Type.cs

Quelle:: Type.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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 IsGenericTypeEigenschaften , IsGenericTypeDefinition, IsGenericParameterund ContainsGenericParameters für die im Abschnitt Hinweise beschriebenen Typen angezeigt. Erläuterungen zu den Eigenschaftswerten finden Sie in der begleitenden Tabelle unter Hinweise.

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 offenen konstruierten Typ oder einen geschlossenen konstruierten Typ darstellt.

Hinweis

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

In der folgenden Tabelle sind die invarianten Bedingungen für allgemeine Begriffe zusammengefasst, die in der generischen 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 angegeben wird. MakeGenericType kann nur bei generischen Typdefinitionen aufgerufen werden. Jede generische Typdefinition ist ein generischer Typ (die IsGenericType Eigenschaft ist `true`), die umgekehrte ist jedoch nicht wahr.
generischer Typ	Die IsGenericType-Eigenschaft ist `true`. Kann eine generische Typdefinition, ein offen konstruierter Typ oder ein geschlossener konstruierter Typ sein. Beachten Sie, dass ein Arraytyp, dessen Elementtyp generisch ist, selbst kein generischer Typ ist. Das gleiche gilt für ein Type Objekt, das einen Zeiger auf einen generischen Typ darstellt.
konstruierter Typ öffnen	Die ContainsGenericParameters-Eigenschaft ist `true`. Beispiele sind ein generischer Typ mit nicht zugewiesenen Typparametern, ein Typ, der in einer generischen Typdefinition oder in einem offenen konstruierten Typ geschachtelt ist, oder ein generischer Typ mit einem Typargument, für das die ContainsGenericParameters -Eigenschaft lautet `true`. Es ist nicht möglich, eine instance eines offen konstruierten Typs zu erstellen. Beachten Sie, dass nicht alle offenen konstruierten Typen generisch sind. Beispielsweise ist ein Array, dessen Elementtyp eine generische Typdefinition ist, nicht generisch, und ein Zeiger auf einen offenen konstruierten Typ ist nicht generisch.
geschlossener konstruierter Typ	Die ContainsGenericParameters-Eigenschaft ist `false`. Bei rekursiver Untersuchung verfügt der Typ über keine nicht zugewiesenen generischen Parameter.
generischer Typparameter	Die IsGenericParameter-Eigenschaft ist `true`. Die ContainsGenericParameters-Eigenschaft ist `true`. In einer generischen Typdefinition ein Platzhalter für einen Typ, der später zugewiesen wird.
generisches Typargument	Kann ein beliebiger Typ sein, einschließlich eines generischen Typparameters. Typargumente werden als Array von Type Objekten angegeben, die beim Erstellen eines erstellten 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 sein.

Das folgende Codebeispiel und die folgende Tabelle veranschaulichen einige dieser Begriffe und Invarianten. Die Derived -Klasse ist von besonderem Interesse, da ihr Basistyp ein konstruierter Typ ist, der eine Mischung aus Typen und Typparametern in seiner 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

Die folgende Tabelle zeigt Beispiele, die die Klassen Base, Derivedund verwenden und Gauf diesen aufbauen. Wenn der C++- und C#-Code identisch sind, 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 ist `false` , weil `d` ein Array ist. IsGenericTypeDefinition ist `false`. ContainsGenericParameters ist `false`.
`T`, `U`und `V` (überall dort, wo sie angezeigt werden)	IsGenericParameter ist `true`. IsGenericType ist `false` , weil es keine Möglichkeit gibt, einen Typparameter auf generische Typen zu beschränken. IsGenericTypeDefinition ist `false`. ContainsGenericParameters ist `true` , weil `T`, `U`und `V` selbst generische Typparameter sind. Dies impliziert nichts über Typargumente, die ihnen später zugewiesen werden.
Feldtyp `F`	IsGenericType ist `true`. IsGenericTypeDefinition ist `false` , weil dem Typparameter von `G`ein Typ zugewiesen wurde. Beachten Sie, dass dies dem Aufruf der MakeGenericType -Methode entspricht. ContainsGenericParameters ist `true` , weil der Typ des Felds `F` über ein Typargument verfügt, bei dem es sich um einen offenen konstruierten Typ handelt. Der konstruierte Typ ist geöffnet, da sein Typargument (d. h. `Base`) eine generische Typdefinition ist. Dies veranschaulicht die rekursive Natur der IsGenericType Eigenschaft.
Die geschachtelte Klasse `Nested`	IsGenericType ist `true`, obwohl die `Nested` Klasse keine eigenen generischen Typparameter aufweist, 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 ist `true` , weil der einschließende Typ , `Derived`über generische Typparameter verfügt. Dies veranschaulicht die rekursive Natur der ContainsGenericParameters Eigenschaft.

Gilt für:

Freigeben über