Type.GetGenericTypeDefinition Metodo

Definizione

Restituisce un oggetto Type che rappresenta una definizione di tipo generico da cui è possibile costruire il tipo generico corrente.Returns a Type object that represents a generic type definition from which the current generic type can be constructed.

public:
 virtual Type ^ GetGenericTypeDefinition();
public virtual Type GetGenericTypeDefinition ();
abstract member GetGenericTypeDefinition : unit -> Type
override this.GetGenericTypeDefinition : unit -> Type
Public Overridable Function GetGenericTypeDefinition () As Type

Restituisce

Oggetto Type che rappresenta un tipo generico da cui è possibile costruire il tipo corrente.A Type object representing a generic type from which the current type can be constructed.

Eccezioni

Il tipo corrente non è generico.The current type is not a generic type. Ciò significa che IsGenericType restituisce false.That is, IsGenericType returns false.

Il metodo richiamato non è supportato nella classe base.The invoked method is not supported in the base class. Le classi derivate devono fornire un'implementazione.Derived classes must provide an implementation.

Esempi

Nell'esempio di codice seguente viene creata un'istanza di un tipo costruito mediante la creazione di un'istanza ordinata GetGenericTypeDefinition , quindi vengono utilizzati i GetType metodi e per recuperare il tipo costruito e la definizione di tipo generico.The following code example creates an instance of a constructed type by using ordinary instance creation and then uses the GetType and GetGenericTypeDefinition methods to retrieve the constructed type and the generic type definition. In questo esempio viene usato Dictionary<TKey,TValue> il tipo generico. il tipo costruito Dictionary<TKey,TValue> rappresenta Test un oggetto di oggetti con chiavi di stringa.This example uses the generic Dictionary<TKey,TValue> type; the constructed type represents a Dictionary<TKey,TValue> of Test objects with string keys.

using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;

public ref class Test
{
public:
   static void Main()
   {
      Console::Write( L"\r\n--- Get the generic type that " );
      Console::WriteLine( L"defines a constructed type." );
     
      // Create a Dictionary of Test objects, using strings for the
      // keys.
      Dictionary< String^,Test^ >^ d = gcnew Dictionary< String^,Test^ >;
      
      // Get a Type object representing the constructed type.
      //
      Type^ constructed = d->GetType();
      DisplayTypeInfo( constructed );
      Type^ myGeneric = constructed->GetGenericTypeDefinition();
      DisplayTypeInfo( myGeneric );
   }

private:
   static void DisplayTypeInfo( Type^ t )
   {
      Console::WriteLine( L"\r\n{0}", t );
      Console::WriteLine( L"\tIs this a generic type definition? {0}",
         t->IsGenericTypeDefinition );
      Console::WriteLine( L"\tIs it a generic type? {0}",
         t->IsGenericType );
      array<Type^>^typeArguments = t->GetGenericArguments();
      Console::WriteLine( L"\tList type arguments ({0}):",
         typeArguments->Length );
      System::Collections::IEnumerator^ myEnum =
         typeArguments->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Type^ tParam = safe_cast<Type^>(myEnum->Current);
         Console::WriteLine( L"\t\t{0}", tParam );
      }
   }
};

int main()
{
   Test::Main();
}

/* This example produces the following output:

--- Get the generic type that defines a constructed type.

System.Collections.Generic.Dictionary`2[System.String,Test]
        Is this a generic type definition? False
        Is it a generic type? True
        List type arguments (2):
                System.String
                Test

System.Collections.Generic.Dictionary`2[TKey,TValue]
        Is this a generic type definition? True
        Is it a generic type? True
        List type arguments (2):
                TKey
                TValue
 */
using System;
using System.Reflection;
using System.Collections.Generic;

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Get the generic type that defines a constructed type.");

        // Create a Dictionary of Test objects, using strings for the
        // keys.       
        Dictionary<string, Test> d = new Dictionary<string, Test>();

        // Get a Type object representing the constructed type.
        //
        Type constructed = d.GetType();
        DisplayTypeInfo(constructed);

        Type generic = constructed.GetGenericTypeDefinition();
        DisplayTypeInfo(generic);
    }

    private static void DisplayTypeInfo(Type t)
    {
        Console.WriteLine("\r\n{0}", t);
        Console.WriteLine("\tIs this a generic type definition? {0}", 
            t.IsGenericTypeDefinition);
        Console.WriteLine("\tIs it a generic type? {0}", 
            t.IsGenericType);
        Type[] typeArguments = t.GetGenericArguments();
        Console.WriteLine("\tList type arguments ({0}):", typeArguments.Length);
        foreach (Type tParam in typeArguments)
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}

/* This example produces the following output:

--- Get the generic type that defines a constructed type.

System.Collections.Generic.Dictionary`2[System.String,Test]
        Is this a generic type definition? False
        Is it a generic type? True
        List type arguments (2):
                System.String
                Test

System.Collections.Generic.Dictionary`2[TKey,TValue]
        Is this a generic type definition? True
        Is it a generic type? True
        List type arguments (2):
                TKey
                TValue
 */
Imports System.Reflection
Imports System.Collections.Generic

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Get the generic type that defines a constructed type.")
        
        ' Create a Dictionary of Test objects, using strings for the
        ' keys.
        Dim d As New Dictionary(Of String, Test)
        
        ' Get a Type object representing the constructed type.
        '
        Dim constructed As Type = d.GetType()
        DisplayTypeInfo(constructed)
        
        Dim generic As Type = constructed.GetGenericTypeDefinition()
        DisplayTypeInfo(generic)
    End Sub
    
    Private Shared Sub DisplayTypeInfo(ByVal t As Type) 
        Console.WriteLine(vbCrLf & t.ToString())
        Console.WriteLine(vbTab & "Is this a generic type definition? " _
            & t.IsGenericTypeDefinition)
        Console.WriteLine(vbTab & "Is it a generic type? " _
            & t.IsGenericType)
        Dim typeArguments As Type() = t.GetGenericArguments()
        Console.WriteLine(vbTab & "List type arguments (" _
            & typeArguments.Length & "):")
        For Each tParam As Type In typeArguments
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        Next tParam
    End Sub
End Class

' This example produces the following output:
'
'--- Get the generic type that defines a constructed type.
'
'System.Collections.Generic.Dictionary`2[System.String,Test]
'        Is this a generic type definition? False
'        Is it a generic type? True
'        List type arguments (2):
'                System.String
'                Test
'
'System.Collections.Generic.Dictionary`2[TKey,TValue]
'        Is this a generic type definition? True
'        Is it a generic type? True
'        List type arguments (2):
'                TKey
'                TValue
' 

Commenti

Una definizione di tipo generico è un modello da cui è possibile costruire altri tipi.A generic type definition is a template from which other types can be constructed. Ad esempio, dalla definizione G<T> di tipo generico (espressa nella C# sintassi; G<int> G(Of Integer) in Visual Basic o generic <typename T> ref class G in C++) è possibile creare e creare un'istanza del tipo (in Visual Basic). G(Of T)For example, from the generic type definition G<T> (expressed in C# syntax; G(Of T) in Visual Basic or generic <typename T> ref class G in C++) you can construct and instantiate the type G<int> (G(Of Integer) in Visual Basic). Dato un Type oggetto che rappresenta questo tipo costruito, GetGenericTypeDefinition il metodo restituisce la definizione di tipo generico.Given a Type object representing this constructed type, the GetGenericTypeDefinition method returns the generic type definition.

Se due tipi costruiti vengono creati dalla stessa definizione di tipo generico, usando gli stessi argomenti di tipo, GetGenericTypeDefinition il metodo restituisce lo Type stesso oggetto per entrambi i tipi.If two constructed types are created from the same generic type definition, using the same type arguments, the GetGenericTypeDefinition method returns the same Type object for both types.

Se si chiama il GetGenericTypeDefinition metodo su un Type oggetto che già rappresenta una definizione di tipo generico, viene restituito l' Typeoggetto corrente.If you call the GetGenericTypeDefinition method on a Type object that already represents a generic type definition, it returns the current Type.

Importante

Una matrice di tipi generici non è a sua volta generica.An array of generic types is not itself generic. Nel codice Dim v() As A(Of Integer)o nel codice Visual Basic, il tipo di variabile v non è generico. A<int>[] v; C#In the C# code A<int>[] v; or the Visual Basic code Dim v() As A(Of Integer), the type of variable v is not generic. Usare IsGenericType per determinare se un tipo è generico prima di GetGenericTypeDefinitionchiamare.Use IsGenericType to determine whether a type is generic before calling GetGenericTypeDefinition.

Per un elenco delle condizioni invariabili relative ai termini usati dal processo di reflection generico, vedere i commenti sulla proprietà IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Si applica a

Vedi anche