Type.IsGenericType Eigenschaft

Definition

Ruft einen Wert ab, der angibt, ob der aktuelle Typ ein generischer Typ ist.Gets a value indicating whether the current type is a generic type.

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

Eigenschaftswert

true, wenn der aktuelle Typ ein generischer Typ ist. falseandernfalls.true if the current type is a generic type; otherwise, false.

Beispiele

Im folgenden Codebeispiel IsGenericTypewird der Wert der Eigenschaften,, IsGenericParameterund ContainsGenericParameters für die Typen angezeigt, die im Abschnitt "Hinweise" beschrieben werden IsGenericTypeDefinition.The following code example displays the value of the IsGenericType, IsGenericTypeDefinition, IsGenericParameter, and ContainsGenericParameters properties for the types described in the Remarks section. Erläuterungen zu den Eigenschafts Werten finden Sie in der zugehörigen Tabelle unter "Hinweise".For explanations of the property values, see the accompanying table in Remarks.

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
 */
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

Mithilfe der IsGenericType -Eigenschaft können Sie fest Type stellen, ob ein-Objekt einen generischen Typ darstellt.Use the IsGenericType property to determine whether a Type object represents a generic type. Verwenden Sie ContainsGenericParameters die-Eigenschaft, um Type zu bestimmen, ob ein-Objekt einen geöffneten konstruierten Typ oder einen geschlossenen konstruierten Typ darstellt.Use the ContainsGenericParameters property to determine whether a Type object represents an open constructed type or a closed constructed type.

Hinweis

Die IsGenericType -Eigenschaft false gibt zurück, wenn der unmittelbare Typ nicht generisch ist.The IsGenericType property returns false if the immediate type is not generic. Beispielsweise ist ein Array, dessen Elemente vom Typ A<int> (A(Of Integer) in Visual Basic) sind, nicht selbst ein generischer Typ.For example, an array whose elements are of type A<int> (A(Of Integer) in Visual Basic) is not itself a generic type.

In der folgenden Tabelle werden die invarianten Bedingungen für allgemeine Begriffe zusammengefasst, die bei allgemeiner Reflektion verwendet werden.The following table summarizes the invariant conditions for common terms used in generic reflection.

BegriffTerm InvarianteInvariant
generische Typdefinitiongeneric type definition Die IsGenericTypeDefinition-Eigenschaft ist true.The IsGenericTypeDefinition property is true.

Definiert einen generischen Typ.Defines a generic type. Ein konstruierter Typ wird erstellt, indem MakeGenericType die-Methode Type für ein-Objekt aufgerufen wird, das eine generische Typdefinition darstellt und ein Array von Typargumenten angibt.A constructed type is created by calling the MakeGenericType method on a Type object that represents a generic type definition and specifying an array of type arguments.

MakeGenericTypekann nur für generische Typdefinitionen aufgerufen werden.MakeGenericType can be called only on generic type definitions.

Jede generische Typdefinition ist ein generischer Typ ( IsGenericType die- trueEigenschaft ist), aber das Gegenteil ist nicht "true".Any generic type definition is a generic type (the IsGenericType property is true), but the converse is not true.
generischer Typgeneric type Die IsGenericType-Eigenschaft ist true.The IsGenericType property is true.

Dabei kann es sich um eine generische Typdefinition, einen offenen konstruierten Typ oder einen geschlossenen konstruierten Typ handeln.Can be a generic type definition, an open constructed type, or a closed constructed type.

Beachten Sie, dass ein Arraytyp, dessen Elementtyp generisch ist, nicht selbst ein generischer Typ ist.Note that an array type whose element type is generic is not itself a generic type. Das gleiche gilt für ein Type -Objekt, das einen Zeiger auf einen generischen Typ darstellt.The same is true of a Type object representing a pointer to a generic type.
erstellter Typ öffnenopen constructed type Die ContainsGenericParameters-Eigenschaft ist true.The ContainsGenericParameters property is true.

Beispiele sind ein generischer Typ, der nicht zugewiesene Typparameter aufweist, ein Typ, der in einer generischen Typdefinition oder in einem geöffneten konstruierten Typ oder ein generischer Typ mit einem Typargument ContainsGenericParameters , für truedas die-Eigenschaft ist, eingebettet ist.Examples are a generic type that has unassigned type parameters, a type that is nested in a generic type definition or in an open constructed type, or a generic type that has a type argument for which the ContainsGenericParameters property is true.

Es ist nicht möglich, eine Instanz eines geöffneten konstruierten Typs zu erstellen.It is not possible to create an instance of an open constructed type.

Beachten Sie, dass nicht alle offenen konstruierten Typen generisch sind.Note that not all open constructed types are generic. Beispielsweise ist ein Array, dessen Elementtyp eine generische Typdefinition ist, nicht generisch, und ein Zeiger auf einen geöffneten konstruierten Typ ist nicht generisch.For example, an array whose element type is a generic type definition is not generic, and a pointer to an open constructed type is not generic.
geschlossener konstruierter Typclosed constructed type Die ContainsGenericParameters-Eigenschaft ist false.The ContainsGenericParameters property is false.

Bei rekursiver unter Prüfung verfügt der Typ nicht über nicht zugewiesene generische Parameter.When examined recursively, the type has no unassigned generic parameters.
generischer Typparametergeneric type parameter Die IsGenericParameter-Eigenschaft ist true.The IsGenericParameter property is true.

Die ContainsGenericParameters-Eigenschaft ist true.The ContainsGenericParameters property is true.

In einer generischen Typdefinition ein Platzhalter für einen Typ, der später zugewiesen wird.In a generic type definition, a placeholder for a type that will be assigned later.
generisches Typargumentgeneric type argument Kann ein beliebiger Typ sein, einschließlich eines generischen Typparameters.Can be any type, including a generic type parameter.

Typargumente werden als Array von Type -Objekten angegeben, MakeGenericType die beim Erstellen eines konstruierten generischen Typs an die Methode übermittelt werden.Type arguments are specified as an array of Type objects passed to the MakeGenericType method when creating a constructed generic type. Wenn Instanzen des resultierenden Typs erstellt werden sollen, muss die ContainsGenericParameters -Eigenschaft für alle Typargumente lauten. falseIf instances of the resulting type are to be created, the ContainsGenericParameters property must be false for all the type arguments.

Im folgenden Codebeispiel und in der Tabelle werden einige dieser Begriffe und invarianten veranschaulicht.The following code example and table illustrate some of these terms and invariants. Die Derived -Klasse ist von besonderem Interesse, da ihr Basistyp ein konstruierter Typ ist, der über eine Mischung aus Typen und Typparametern in der Typargument Liste verfügt.The Derived class is of particular interest because its base type is a constructed type that has a mixture of types and type parameters in its type argument list.

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> {}
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, in denen die- BaseKlassen Derived, und Gverwendet und erstellt werden.The following table shows examples that use and build on the classes Base, Derived, and G. Wenn der C++ - C# und der-Code identisch sind, wird nur ein Eintrag angezeigt.When the C++ and C# code is the same, only one entry is shown.

BeispielExample InvariantenInvariants
Derived(Of V)

Derived<V>
Für diesen Typ:For this type:

IsGenericType ist true.IsGenericType is true.

IsGenericTypeDefinition ist true.IsGenericTypeDefinition is true.

ContainsGenericParameters ist true.ContainsGenericParameters is true.
Base(Of String, V)

Base<String,V>

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

IsGenericType ist true.IsGenericType is true.

IsGenericTypeDefinition ist false.IsGenericTypeDefinition is false.

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

Derived<int>[] d;

array<Derived<int>^>^ d;
Für den Typ der Variablen d:For the type of variable d:

IsGenericTypeist false , d weil ein Array ist.IsGenericType is false because d is an array.

IsGenericTypeDefinition ist false.IsGenericTypeDefinition is false.

ContainsGenericParameters ist false.ContainsGenericParameters is false.
T, U undV (überall angezeigt)T, U, and V (everywhere they appear) IsGenericParameter ist true.IsGenericParameter is true.

IsGenericTypeliegt false daran, dass es keine Möglichkeit gibt, einen Typparameter auf generische Typen zu beschränken.IsGenericType is false because there is no way to constrain a type parameter to generic types.

IsGenericTypeDefinition ist false.IsGenericTypeDefinition is false.

ContainsGenericParametersliegt true daran T, Udass, undV selbst generische Typparameter sind.ContainsGenericParameters is true because T, U, and V are themselves generic type parameters. Dies impliziert nicht etwas über Typargumente, die später zugewiesen werden.This does not imply anything about type arguments that are assigned to them later.
Der Feldtyp.FThe type of field F IsGenericType ist true.IsGenericType is true.

IsGenericTypeDefinitionliegt false daran, dass dem Typparameter von Gein Typ zugewiesen wurde.IsGenericTypeDefinition is false because a type has been assigned to the type parameter of G. Beachten Sie, dass dies der MakeGenericType Methode entspricht.Note that this is equivalent to having called the MakeGenericType method.

ContainsGenericParametersliegt true daran, dass der Feldtyp F über ein Typargument verfügt, das ein offener konstruierter Typ ist.ContainsGenericParameters is true because the type of field F has a type argument that is an open constructed type. Der konstruierte Typ ist offen, da sein Typargument ( Based. h.) eine generische Typdefinition ist.The constructed type is open because its type argument (that is, Base) is a generic type definition. Dadurch wird die rekursive Natur der IsGenericType Eigenschaft veranschaulicht.This illustrates the recursive nature of the IsGenericType property.
Die-Klasse, die die KlasseNestedThe nested class Nested IsGenericTypeist true, obwohl die Nested -Klasse über keine eigenen generischen Typparameter verfügt, da Sie in einem generischen Typ eingebettet ist.IsGenericType is true, even though the Nested class has no generic type parameters of its own, because it is nested in a generic type.

IsGenericTypeDefinition ist true.IsGenericTypeDefinition is true. Das heißt, Sie können die MakeGenericType -Methode aufrufen und den Typparameter des einschließenden DerivedTyps angeben.That is, you can call the MakeGenericType method and supply the type parameter of the enclosing type, Derived.

ContainsGenericParametersliegt true daran, dass der einschließende DerivedTyp,, über generische Typparameter verfügt.ContainsGenericParameters is true because the enclosing type, Derived, has generic type parameters. Dadurch wird die rekursive Natur der ContainsGenericParameters Eigenschaft veranschaulicht.This illustrates the recursive nature of the ContainsGenericParameters property.

Gilt für:

Siehe auch