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.

下表总结了泛型反射中的常用术语的固定条件。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(不管它们出现)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.

适用于

另请参阅