Type.GetGenericTypeDefinition Type.GetGenericTypeDefinition Type.GetGenericTypeDefinition Type.GetGenericTypeDefinition Method

Definición

Devuelve un objeto Type que representa una definición de tipo genérico a partir de la cual se puede construir el tipo genérico actual.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

Devoluciones

Objeto Type que representa un tipo genérico a partir del cual se puede construir el tipo actual.A Type object representing a generic type from which the current type can be constructed.

Excepciones

El tipo actual no es un tipo genérico.The current type is not a generic type. Es decir, IsGenericType devuelve false.That is, IsGenericType returns false.

El método invocado no se admite en la clase base.The invoked method is not supported in the base class. Las clases derivadas deben proporcionar una implementación.Derived classes must provide an implementation.

Ejemplos

En el ejemplo de código siguiente se crea una instancia de un tipo construido utilizando la creación de instancia normal GetType y GetGenericTypeDefinition , a continuación, se usan los métodos y para recuperar el tipo construido y la definición de tipo genérico.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. En este ejemplo se usa Dictionary<TKey,TValue> el tipo genérico; el tipo construido Dictionary<TKey,TValue> representa Test un de objetos con claves de cadena.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 'Test

' 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
' 

Comentarios

Una definición de tipo genérico es una plantilla a partir de la cual se pueden construir otros tipos.A generic type definition is a template from which other types can be constructed. Por ejemplo, de la definición G<T> de tipo genérico (expresada en C# sintaxis; G<int> G(Of Integer) en Visual Basic o generic <typename T> ref class G en C++) puede construir y crear instancias del tipo (en 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). Dado un Type objeto que representa este tipo construido, GetGenericTypeDefinition el método devuelve la definición de tipo genérico.Given a Type object representing this constructed type, the GetGenericTypeDefinition method returns the generic type definition.

Si dos tipos construidos se crean a partir de la misma definición de tipo genérico, utilizando los mismos argumentos GetGenericTypeDefinition de tipo, el Type método devuelve el mismo objeto para ambos tipos.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.

Si llama al GetGenericTypeDefinition método en un Type objeto que ya representa una definición de tipo genérico, devuelve el actual Type.If you call the GetGenericTypeDefinition method on a Type object that already represents a generic type definition, it returns the current Type.

Importante

Una matriz de tipos genéricos no es genérica.An array of generic types is not itself generic. En el C# A<int>[] v; código o en el código Dim v() As A(Of Integer)Visual Basic, el tipo de v variable no es genérico.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. Utilice IsGenericType para determinar si un tipo es genérico antes de GetGenericTypeDefinitionllamar a.Use IsGenericType to determine whether a type is generic before calling GetGenericTypeDefinition.

Para obtener una lista de las condiciones invariables para los términos usados en la reflexión genérica, vea los comentarios de la propiedad IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Se aplica a

Consulte también: