Type.IsGenericType Type.IsGenericType Type.IsGenericType Type.IsGenericType Property

定義

取得值,指出目前類型是否為泛型類型。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

屬性值

true 如果目前的型別為泛型類型,否則, falsetrue if the current type is a generic type; otherwise, false.

範例

下列程式碼範例顯示的值IsGenericTypeIsGenericTypeDefinitionIsGenericParameter,和ContainsGenericParameters< 備註 > 一節所述的類型屬性。The following code example displays the value of the IsGenericType, IsGenericTypeDefinition, IsGenericParameter, and ContainsGenericParameters properties for the types described in the Remarks section. 如需更多的屬性值的說明,請參閱 < 備註 > 中的表格。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
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

備註

使用IsGenericType屬性來判斷是否Type物件代表泛型類型。Use the IsGenericType property to determine whether a Type object represents a generic type. 使用ContainsGenericParameters屬性來判斷是否Type物件都代表開放式建構的類型或封閉式的建構型別。Use the ContainsGenericParameters property to determine whether a Type object represents an open constructed type or a closed constructed type.

注意

IsGenericType屬性會傳回false如果立即的型別不是泛型。The IsGenericType property returns false if the immediate type is not generic. 比方說,其項目屬於型別陣列A<int>(A(Of Integer) Visual Basic 中) 會本身不是泛型型別。For example, an array whose elements are of type A<int> (A(Of Integer) in Visual Basic) is not itself a generic type.

下表摘要說明非變異條件 hapi 一般條款泛型反映中所使用。The following table summarizes the invariant conditions for common terms used in generic reflection.

詞彙Term 非變異值Invariant
Generic Type Definition - 泛型類型定義generic type definition IsGenericTypeDefinition 屬性為 trueThe IsGenericTypeDefinition property is true.

定義泛型型別。Defines a generic type. 建構的型別由呼叫MakeGenericType方法Type物件代表泛型類型定義,並指定型別引數陣列。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.

MakeGenericType 可以只在泛型類型定義上呼叫。MakeGenericType can be called only on generic type definitions.

任何泛型型別定義為泛型類型 (IsGenericType屬性是true),但是反過來說就不正確。Any generic type definition is a generic type (the IsGenericType property is true), but the converse is not true.
Generic Type - 泛型類型generic type IsGenericType 屬性為 trueThe IsGenericType property is true.

可以是泛型類型定義、 開放式建構的類型或封閉式的建構型別。Can be a generic type definition, an open constructed type, or a closed constructed type.

請注意,陣列類型的項目型別是泛型本身就不是泛型型別。Note that an array type whose element type is generic is not itself a generic type. 也是如此的Type物件,代表泛型類型的指標。The same is true of a Type object representing a pointer to a generic type.
開放式建構的類型open constructed type ContainsGenericParameters 屬性為 trueThe ContainsGenericParameters property is true.

範例包括已指派的型別參數的泛型型別、 開放式建構類型,或泛型類型定義中巢狀型別或具有類型引數的泛型型別ContainsGenericParameters屬性是trueExamples 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.

您不可能建立開放式建構類型的執行個體。It is not possible to create an instance of an open constructed type.

請注意,並非所有開放式建構的類型是泛型。Note that not all open constructed types are generic. 例如,其項目類型是泛型型別定義陣列不是泛型,而開放式建構類型的指標不是泛型。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.
封閉式建構的類型closed constructed type ContainsGenericParameters 屬性為 falseThe ContainsGenericParameters property is false.

當遞迴檢查,型別沒有任何未指派的泛型參數。When examined recursively, the type has no unassigned generic parameters.
Generic Type Parameter - 泛型型別參數generic type parameter IsGenericParameter 屬性為 trueThe IsGenericParameter property is true.

ContainsGenericParameters 屬性為 trueThe ContainsGenericParameters property is true.

在泛型類型定義中,將會稍後再指派類型的預留位置。In a generic type definition, a placeholder for a type that will be assigned later.
Generic Type Argument - 泛型類型引數generic type argument 可以是任何類型,包括泛型類型參數。Can be any type, including a generic type parameter.

型別引數會指定為陣列Type物件傳遞至MakeGenericType方法建立建構的泛型型別時。Type arguments are specified as an array of Type objects passed to the MakeGenericType method when creating a constructed generic type. 如果產生之型別的執行個體建立ContainsGenericParameters屬性必須是false所有型別引數。If instances of the resulting type are to be created, the ContainsGenericParameters property must be false for all the type arguments.

下列程式碼範例及下表說明其中一些詞彙和非變異值。The following code example and table illustrate some of these terms and invariants. Derived類別,特別感興趣的因為其基底型別建構的型別具有混合型別和型別參數,其型別引數清單中。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

下表顯示範例會使用建立的類別BaseDerived,和GThe following table shows examples that use and build on the classes Base, Derived, and G. 當C++和C#程式碼相同,只有一個項目會顯示。When the C++ and C# code is the same, only one entry is shown.

範例Example 非變異值Invariants
Derived(Of V)

Derived<V>
這種類型:For this type:

IsGenericTypetrueIsGenericType is true.

IsGenericTypeDefinitiontrueIsGenericTypeDefinition is true.

ContainsGenericParameterstrueContainsGenericParameters is true.
Base(Of String, V)

Base<String,V>

Base<String^,V>
這種類型:For this type:

IsGenericTypetrueIsGenericType is true.

IsGenericTypeDefinitionfalseIsGenericTypeDefinition is false.

ContainsGenericParameterstrueContainsGenericParameters is true.
Dim d() As Derived(Of Integer)

Derived<int>[] d;

array<Derived<int>^>^ d;
類型的變數d:For the type of variable d:

IsGenericTypefalse因為d是陣列。IsGenericType is false because d is an array.

IsGenericTypeDefinitionfalseIsGenericTypeDefinition is false.

ContainsGenericParametersfalseContainsGenericParameters is false.
T``U,和V(everywhere 顯示)T, U, and V (everywhere they appear) IsGenericParametertrueIsGenericParameter is true.

IsGenericTypefalse因為沒有任何方法來限制泛型類型的類型參數。IsGenericType is false because there is no way to constrain a type parameter to generic types.

IsGenericTypeDefinitionfalseIsGenericTypeDefinition is false.

ContainsGenericParameterstrue因為TU,和V本身是泛型型別參數。ContainsGenericParameters is true because T, U, and V are themselves generic type parameters. 這不表示有關稍後指派給他們的型別引數的任何項目。This does not imply anything about type arguments that are assigned to them later.
欄位的型別 FThe type of field F IsGenericTypetrueIsGenericType is true.

IsGenericTypeDefinitionfalse因為型別具有指定的型別參數給GIsGenericTypeDefinition is false because a type has been assigned to the type parameter of G. 請注意,這相當於呼叫MakeGenericType方法。Note that this is equivalent to having called the MakeGenericType method.

ContainsGenericParameterstrue因為欄位的型別F已是開放式建構的類型的類型引數。ContainsGenericParameters is true because the type of field F has a type argument that is an open constructed type. 建構的型別為開放型因為其型別引數 (也就是Base) 是泛型類型定義。The constructed type is open because its type argument (that is, Base) is a generic type definition. 這說明的遞迴本質IsGenericType屬性。This illustrates the recursive nature of the IsGenericType property.
巢狀的類別 NestedThe nested class Nested IsGenericTypetrue,即使Nested類別具有自己的沒有泛型類型參數,因為它巢狀在泛型型別。IsGenericType is true, even though the Nested class has no generic type parameters of its own, because it is nested in a generic type.

IsGenericTypeDefinitiontrueIsGenericTypeDefinition is true. 也就是說,您可以呼叫MakeGenericType方法,並提供封入類型,型別參數DerivedThat is, you can call the MakeGenericType method and supply the type parameter of the enclosing type, Derived.

ContainsGenericParameterstrue封入類型,因為Derived,泛型類型參數。ContainsGenericParameters is true because the enclosing type, Derived, has generic type parameters. 這說明的遞迴本質ContainsGenericParameters屬性。This illustrates the recursive nature of the ContainsGenericParameters property.

適用於

另請參閱