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

Definizione

Ottiene un valore che indica se il tipo corrente è un tipo generico.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

Valore della proprietà

trueSe il tipo corrente è un tipo generico; in caso falsecontrario,.true if the current type is a generic type; otherwise, false.

Esempi

Nell'esempio di codice seguente viene visualizzato il valore IsGenericTypedelle IsGenericTypeDefinitionproprietà IsGenericParameter,, ContainsGenericParameters e per i tipi descritti nella sezione Osservazioni.The following code example displays the value of the IsGenericType, IsGenericTypeDefinition, IsGenericParameter, and ContainsGenericParameters properties for the types described in the Remarks section. Per le spiegazioni dei valori delle proprietà, vedere la tabella associata in note.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

Commenti

Utilizzare la IsGenericType proprietà per determinare se un Type oggetto rappresenta un tipo generico.Use the IsGenericType property to determine whether a Type object represents a generic type. Utilizzare la ContainsGenericParameters proprietà per determinare se un Type oggetto rappresenta un tipo costruito aperto o un tipo costruito chiuso.Use the ContainsGenericParameters property to determine whether a Type object represents an open constructed type or a closed constructed type.

Nota

La IsGenericType proprietà restituisce false se il tipo immediato non è generico.The IsGenericType property returns false if the immediate type is not generic. Ad esempio, una matrice i cui elementi sono di A<int> tipoA(Of Integer) (in Visual Basic) non è a sua volta un tipo generico.For example, an array whose elements are of type A<int> (A(Of Integer) in Visual Basic) is not itself a generic type.

Nella tabella seguente sono riepilogate le condizioni invariabili per i termini comuni utilizzati nella reflection generica.The following table summarizes the invariant conditions for common terms used in generic reflection.

TermineTerm InvarianteInvariant
definizione di tipo genericogeneric type definition La proprietà IsGenericTypeDefinition è true.The IsGenericTypeDefinition property is true.

Definisce un tipo generico.Defines a generic type. Un tipo costruito viene creato chiamando il MakeGenericType metodo su un Type oggetto che rappresenta una definizione di tipo generico e specificando una matrice di argomenti di 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.

MakeGenericTypepuò essere chiamato solo su definizioni di tipo generico.MakeGenericType can be called only on generic type definitions.

Qualsiasi definizione di tipo generico è un tipo generico ( IsGenericType la proprietà trueè), ma il contrario non è vero.Any generic type definition is a generic type (the IsGenericType property is true), but the converse is not true.
tipo genericogeneric type La proprietà IsGenericType è true.The IsGenericType property is true.

Può essere una definizione di tipo generico, un tipo costruito aperto o un tipo costruito chiuso.Can be a generic type definition, an open constructed type, or a closed constructed type.

Si noti che un tipo di matrice il cui tipo di elemento è generico non è a sua volta un tipo generico.Note that an array type whose element type is generic is not itself a generic type. Lo stesso vale per un Type oggetto che rappresenta un puntatore a un tipo generico.The same is true of a Type object representing a pointer to a generic type.
tipo costruito apertoopen constructed type La proprietà ContainsGenericParameters è true.The ContainsGenericParameters property is true.

Gli esempi sono un tipo generico con parametri di tipo non assegnati, un tipo annidato in una definizione di tipo generico o in un tipo costruito aperto oppure un tipo generico con un argomento di tipo per il quale ContainsGenericParameters la proprietà trueè.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.

Non è possibile creare un'istanza di un tipo costruito aperto.It is not possible to create an instance of an open constructed type.

Si noti che non tutti i tipi costruiti aperti sono generici.Note that not all open constructed types are generic. Una matrice il cui tipo di elemento è una definizione di tipo generico, ad esempio, non è generica e un puntatore a un tipo costruito aperto non è generico.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 costruito chiusoclosed constructed type La proprietà ContainsGenericParameters è false.The ContainsGenericParameters property is false.

Quando vengono esaminati in modo ricorsivo, il tipo non dispone di parametri generici non assegnati.When examined recursively, the type has no unassigned generic parameters.
parametro di tipo genericogeneric type parameter La proprietà IsGenericParameter è true.The IsGenericParameter property is true.

La proprietà ContainsGenericParameters è true.The ContainsGenericParameters property is true.

In una definizione di tipo generico, un segnaposto per un tipo che verrà assegnato in un secondo momento.In a generic type definition, a placeholder for a type that will be assigned later.
argomento di tipo genericogeneric type argument Può essere qualsiasi tipo, incluso un parametro di tipo generico.Can be any type, including a generic type parameter.

Gli argomenti di tipo vengono specificati come una Type matrice di oggetti passati MakeGenericType al metodo durante la creazione di un tipo generico costruito.Type arguments are specified as an array of Type objects passed to the MakeGenericType method when creating a constructed generic type. Se è necessario creare istanze del tipo risultante, la ContainsGenericParameters proprietà deve essere false per tutti gli argomenti di tipo.If instances of the resulting type are to be created, the ContainsGenericParameters property must be false for all the type arguments.

L'esempio di codice e la tabella seguenti illustrano alcuni di questi termini e invarianti.The following code example and table illustrate some of these terms and invariants. La Derived classe è di particolare interesse perché il tipo di base è un tipo costruito che dispone di una combinazione di tipi e parametri di tipo nell'elenco di argomenti di 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

Nella tabella seguente vengono illustrati esempi che usano e si basano Derivedsulle classi G Base, e.The following table shows examples that use and build on the classes Base, Derived, and G. Quando il C++ codice C# e è lo stesso, viene visualizzata una sola voce.When the C++ and C# code is the same, only one entry is shown.

EsempioExample InvariantiInvariants
Derived(Of V)

Derived<V>
Per questo 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>
Per questo 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;
Per il tipo di variabile d:For the type of variable d:

IsGenericTypeè false perchéd è una matrice.IsGenericType is false because d is an array.

IsGenericTypeDefinition è false.IsGenericTypeDefinition is false.

ContainsGenericParameters è false.ContainsGenericParameters is false.
T, U eV (ovunque si trovino)T, U, and V (everywhere they appear) IsGenericParameter è true.IsGenericParameter is true.

IsGenericTypeè false perché non esiste alcun modo per vincolare un parametro di tipo ai tipi generici.IsGenericType is false because there is no way to constrain a type parameter to generic types.

IsGenericTypeDefinition è false.IsGenericTypeDefinition is false.

ContainsGenericParametersè true perché T V , eUsono stessi parametri di tipo generico.ContainsGenericParameters is true because T, U, and V are themselves generic type parameters. Ciò non implica alcun argomento sugli argomenti di tipo assegnati in un secondo momento.This does not imply anything about type arguments that are assigned to them later.
Tipo di campoFThe type of field F IsGenericType è true.IsGenericType is true.

IsGenericTypeDefinitionè false perché è stato assegnato un tipo al parametro di tipo di G.IsGenericTypeDefinition is false because a type has been assigned to the type parameter of G. Si noti che questa operazione equivale a avere chiamato MakeGenericType il metodo.Note that this is equivalent to having called the MakeGenericType method.

ContainsGenericParametersè true perché il tipo di campo F ha un argomento di tipo che è un tipo costruito aperto.ContainsGenericParameters is true because the type of field F has a type argument that is an open constructed type. Il tipo costruito è aperto perché il relativo argomento di tipo, ovvero Base, è una definizione di tipo generico.The constructed type is open because its type argument (that is, Base) is a generic type definition. Viene illustrata la natura ricorsiva della IsGenericType proprietà.This illustrates the recursive nature of the IsGenericType property.
Classe annidataNestedThe nested class Nested IsGenericTypeè true, anche se la Nested classe non dispone di parametri di tipo generico, perché è annidata in un tipo generico.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. Ovvero, è possibile chiamare il MakeGenericType metodo e specificare il parametro di tipo del tipo di inclusione,. DerivedThat is, you can call the MakeGenericType method and supply the type parameter of the enclosing type, Derived.

ContainsGenericParametersè true perché il tipo di inclusione Derived,, dispone di parametri di tipo generico.ContainsGenericParameters is true because the enclosing type, Derived, has generic type parameters. Viene illustrata la natura ricorsiva della ContainsGenericParameters proprietà.This illustrates the recursive nature of the ContainsGenericParameters property.

Si applica a

Vedi anche