Type.IsGenericType Propriedade

Definição

Obtém um valor que indica se o tipo atual é um tipo genérico.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

Valor da propriedade

true se o tipo atual é um tipo genérico; caso contrário, false.true if the current type is a generic type; otherwise, false.

Exemplos

O exemplo de código a seguir exibe o valor IsGenericTypedas IsGenericTypeDefinition ContainsGenericParameters propriedades IsGenericParameter,, e para os tipos descritos na seção comentários.The following code example displays the value of the IsGenericType, IsGenericTypeDefinition, IsGenericParameter, and ContainsGenericParameters properties for the types described in the Remarks section. Para obter explicações sobre os valores de propriedade, consulte a tabela que acompanha em comentários.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

Comentários

Use a IsGenericType propriedade para determinar se um Type objeto representa um tipo genérico.Use the IsGenericType property to determine whether a Type object represents a generic type. Use a ContainsGenericParameters propriedade para determinar se um Type objeto representa um tipo construído aberto ou um tipo construído fechado.Use the ContainsGenericParameters property to determine whether a Type object represents an open constructed type or a closed constructed type.

Observação

A IsGenericType propriedade retornará false se o tipo imediato não for genérico.The IsGenericType property returns false if the immediate type is not generic. Por exemplo, uma matriz cujos elementos são do tipo A<int> (A(Of Integer) em Visual Basic) não é, em si, um tipo genérico.For example, an array whose elements are of type A<int> (A(Of Integer) in Visual Basic) is not itself a generic type.

A tabela a seguir resume as condições invariáveis para termos comuns usados em reflexão genérica.The following table summarizes the invariant conditions for common terms used in generic reflection.

TermoTerm ConstanteInvariant
definição de tipo genéricogeneric type definition A propriedade IsGenericTypeDefinition é true.The IsGenericTypeDefinition property is true.

Define um tipo genérico.Defines a generic type. Um tipo construído é criado chamando-se MakeGenericType o método em Type um objeto que representa uma definição de tipo genérico e especificando uma matriz de argumentos de tipo.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.

MakeGenericTypepode ser chamado somente em definições de tipo genérico.MakeGenericType can be called only on generic type definitions.

Qualquer definição de tipo genérico é um tipo genérico ( IsGenericType a propriedade trueé), mas o contrário não é verdadeiro.Any generic type definition is a generic type (the IsGenericType property is true), but the converse is not true.
tipo genéricogeneric type A propriedade IsGenericType é true.The IsGenericType property is true.

Pode ser uma definição de tipo genérico, um tipo construído aberto ou um tipo construído fechado.Can be a generic type definition, an open constructed type, or a closed constructed type.

Observe que um tipo de matriz cujo tipo de elemento é genérico não é, em si, um tipo genérico.Note that an array type whose element type is generic is not itself a generic type. O mesmo é verdadeiro para um Type objeto que representa um ponteiro para um tipo genérico.The same is true of a Type object representing a pointer to a generic type.
Abrir tipo construídoopen constructed type A propriedade ContainsGenericParameters é true.The ContainsGenericParameters property is true.

Os exemplos são um tipo genérico que tem parâmetros de tipo não atribuídos, um tipo que é aninhado em uma definição de tipo genérico ou em um tipo construído aberto, ou um tipo genérico que tem um argumento ContainsGenericParameters de tipo truepara o qual a propriedade é.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.

Não é possível criar uma instância de um tipo construído aberto.It is not possible to create an instance of an open constructed type.

Observe que nem todos os tipos construídos abertos são genéricos.Note that not all open constructed types are generic. Por exemplo, uma matriz cujo tipo de elemento é uma definição de tipo genérico não é genérica e um ponteiro para um tipo construído aberto não é genérico.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.
tipo construído fechadoclosed constructed type A propriedade ContainsGenericParameters é false.The ContainsGenericParameters property is false.

Quando examinado recursivamente, o tipo não tem parâmetros genéricos não atribuídos.When examined recursively, the type has no unassigned generic parameters.
parâmetro de tipo genéricogeneric type parameter A propriedade IsGenericParameter é true.The IsGenericParameter property is true.

A propriedade ContainsGenericParameters é true.The ContainsGenericParameters property is true.

Em uma definição de tipo genérico, um espaço reservado para um tipo que será atribuído posteriormente.In a generic type definition, a placeholder for a type that will be assigned later.
argumento de tipo genéricogeneric type argument Pode ser qualquer tipo, incluindo um parâmetro de tipo genérico.Can be any type, including a generic type parameter.

Os argumentos de tipo são especificados como uma Type matriz de objetos passados MakeGenericType para o método durante a criação de um tipo genérico construído.Type arguments are specified as an array of Type objects passed to the MakeGenericType method when creating a constructed generic type. Se forem criadas instâncias do tipo resultante, a ContainsGenericParameters Propriedade deverá ser false para todos os argumentos de tipo.If instances of the resulting type are to be created, the ContainsGenericParameters property must be false for all the type arguments.

O exemplo de código e a tabela a seguir ilustram alguns desses termos e invariáveis.The following code example and table illustrate some of these terms and invariants. A Derived classe é de interesse particular porque seu tipo base é um tipo construído que tem uma mistura de tipos e parâmetros de tipo em sua lista de argumentos de tipo.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

A tabela a seguir mostra exemplos que usam e se baseiam Basenas Derivedclasses, Ge.The following table shows examples that use and build on the classes Base, Derived, and G. Quando o C++ e C# o código são os mesmos, apenas uma entrada é mostrada.When the C++ and C# code is the same, only one entry is shown.

ExemploExample InvariáveisInvariants
Derived(Of V)

Derived<V>
Para este tipo:For this type:

IsGenericType é true.IsGenericType is true.

IsGenericTypeDefinition é true.IsGenericTypeDefinition is true.

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

Base<String,V>

Base<String^,V>
Para este tipo:For this type:

IsGenericType é true.IsGenericType is true.

IsGenericTypeDefinition é false.IsGenericTypeDefinition is false.

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

Derived<int>[] d;

array<Derived<int>^>^ d;
Para o tipo de variável d:For the type of variable d:

IsGenericTypeé false porqued é uma matriz.IsGenericType is false because d is an array.

IsGenericTypeDefinition é false.IsGenericTypeDefinition is false.

ContainsGenericParameters é false.ContainsGenericParameters is false.
T, Ue ( V em todos os lugares eles aparecem)T, U, and V (everywhere they appear) IsGenericParameter é true.IsGenericParameter is true.

IsGenericTypeé false porque não há nenhuma maneira de restringir um parâmetro de tipo para tipos genéricos.IsGenericType is false because there is no way to constrain a type parameter to generic types.

IsGenericTypeDefinition é false.IsGenericTypeDefinition is false.

ContainsGenericParametersocorre true Uporque ,eV são parâmetros de tipo genéricos. TContainsGenericParameters is true because T, U, and V are themselves generic type parameters. Isso não significa nada sobre argumentos de tipo que são atribuídos a eles mais tarde.This does not imply anything about type arguments that are assigned to them later.
O tipo de campoFThe type of field F IsGenericType é true.IsGenericType is true.

IsGenericTypeDefinitioné false porque um tipo foi atribuído ao parâmetro de tipo de G.IsGenericTypeDefinition is false because a type has been assigned to the type parameter of G. Observe que isso é equivalente a chamar o MakeGenericType método.Note that this is equivalent to having called the MakeGenericType method.

ContainsGenericParametersé true porque o tipo de campo F tem um argumento de tipo que é um tipo construído aberto.ContainsGenericParameters is true because the type of field F has a type argument that is an open constructed type. O tipo construído é aberto porque seu argumento de tipo (ou seja Base,) é uma definição de tipo genérico.The constructed type is open because its type argument (that is, Base) is a generic type definition. Isso ilustra a natureza recursiva da IsGenericType propriedade.This illustrates the recursive nature of the IsGenericType property.
A classe aninhadaNestedThe nested class Nested IsGenericTypeé true, mesmo que a Nested classe não tenha nenhum parâmetro de tipo genérico, porque está aninhada em um tipo genérico.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 é true.IsGenericTypeDefinition is true. Ou seja, você pode chamar o MakeGenericType método e fornecer o parâmetro de tipo do tipo delimitador Derived,.That is, you can call the MakeGenericType method and supply the type parameter of the enclosing type, Derived.

ContainsGenericParametersocorre true porque o tipo de delimitador,, tem parâmetros de Derivedtipo genérico.ContainsGenericParameters is true because the enclosing type, Derived, has generic type parameters. Isso ilustra a natureza recursiva da ContainsGenericParameters propriedade.This illustrates the recursive nature of the ContainsGenericParameters property.

Aplica-se a

Veja também