Cómo: Examinar y crear instancias de tipos genéricos mediante la reflexión

Artículo
08/23/2008

Actualización: noviembre 2007

La información de tipos genéricos se obtiene de la misma manera que la información sobre otros tipos: examinando un objeto Type que representa el tipo genérico. La diferencia de principio es que un tipo genérico tiene una lista de objetos Type que representan sus parámetros de tipo genérico. El primer procedimiento de esta sección examina los tipos genéricos.

Puede crear un objeto Type que representa un tipo construido enlazando los argumentos de tipo a los parámetros de tipo de una definición de tipo genérico. Todo ello se explica en el segundo procedimiento.

Para examinar un tipo genérico y sus parámetros de tipo

Obtenga una instancia de Type que represente el tipo genérico. En el código siguiente, el tipo se obtiene utilizando el operador typeof de C# (GetType en Visual Basic, typeid en Visual C++). Vea el tema de la clase Type para conocer otras maneras de obtener un objeto Type. Tenga en cuenta que en el resto de este procedimiento, el tipo se contiene en un parámetro de método denominado t.
```
Dim d1 As Type = GetType(Dictionary(Of ,))
```
```
Type d1 = typeof(Dictionary<,>);
```

Utilice la propiedad IsGenericType para determinar si el tipo es genérico y utilice la propiedad IsGenericTypeDefinition para determinar si el tipo es una definición de tipo genérico.

Console.WriteLine("   Is this a generic type? " _ 
    & t.IsGenericType)
Console.WriteLine("   Is this a generic type definition? " _ 
    & t.IsGenericTypeDefinition)

Console.WriteLine("   Is this a generic type? {0}",
    t.IsGenericType);
Console.WriteLine("   Is this a generic type definition? {0}",
    t.IsGenericTypeDefinition);

Obtenga una matriz que contiene los argumentos de tipo genérico utilizando el método GetGenericArguments.

Dim typeParameters() As Type = t.GetGenericArguments()

Type[] typeParameters = t.GetGenericArguments();

Para cada argumento de tipo, determine si se trata de un parámetro de tipo (por ejemplo, en una definición de tipo genérico) o un tipo especificado para un parámetro de tipo (por ejemplo, en un tipo construido), utilizando la propiedad IsGenericParameter.

Console.WriteLine("   List {0} type arguments:", _
    typeParameters.Length)
For Each tParam As Type In typeParameters
    If tParam.IsGenericParameter Then
        DisplayGenericParameter(tParam)
    Else
        Console.WriteLine("      Type argument: {0}", _
            tParam)
    End If
Next

Console.WriteLine("   List {0} type arguments:", 
    typeParameters.Length);
foreach( Type tParam in typeParameters )
{
    if (tParam.IsGenericParameter)
    {
        DisplayGenericParameter(tParam);
    }
    else
    {
        Console.WriteLine("      Type argument: {0}",
            tParam);
    }
}

En el sistema de tipos, una instancia de Type representa un parámetro de tipo genérico, igual que ocurre con los tipos normales. El código siguiente muestra el nombre y la posición de parámetro de un objeto Type que representa un parámetro de tipo genérico. La posición del parámetro es aquí información trivial; resulta de más interés cuando está examinando un parámetro de tipo que se ha utilizado como un argumento de tipo de otro tipo genérico.
```
Private Shared Sub DisplayGenericParameter(ByVal tp As Type)
    Console.WriteLine("      Type parameter: {0} position {1}", _
        tp.Name, tp.GenericParameterPosition)
```
```
private static void DisplayGenericParameter(Type tp)
{
    Console.WriteLine("      Type parameter: {0} position {1}", 
        tp.Name, tp.GenericParameterPosition);
```

Determine la restricción de tipo base y las restricciones de interfaz de un parámetro de tipo genérico utilizando el método GetGenericParameterConstraints para obtener todas las restricciones de una única matriz. No se garantiza que las restricciones sigan ningún orden determinado.

Dim classConstraint As Type = Nothing

For Each iConstraint As Type In tp.GetGenericParameterConstraints()
    If iConstraint.IsInterface Then
        Console.WriteLine("         Interface constraint: {0}", _
            iConstraint)
    End If
Next

If classConstraint IsNot Nothing Then
    Console.WriteLine("         Base type constraint: {0}", _
        tp.BaseType)
Else
    Console.WriteLine("         Base type constraint: None")
End If

Type classConstraint = null;

foreach(Type iConstraint in tp.GetGenericParameterConstraints())
{
    if (iConstraint.IsInterface)
    {
        Console.WriteLine("         Interface constraint: {0}",
            iConstraint);
    }
}

if (classConstraint != null)
{
    Console.WriteLine("         Base type constraint: {0}", 
        tp.BaseType);
}
else
    Console.WriteLine("         Base type constraint: None");

Utilice la propiedad GenericParameterAttributes para descubrir las restricciones especiales de un parámetro de tipo, como requerir que sea un tipo de referencia. La propiedad también incluye valores que representan variación, que puede enmascarar como se muestra en el código siguiente.
```
Dim sConstraints As GenericParameterAttributes = _
    tp.GenericParameterAttributes And _
    GenericParameterAttributes.SpecialConstraintMask
```
```
GenericParameterAttributes sConstraints = 
    tp.GenericParameterAttributes & 
    GenericParameterAttributes.SpecialConstraintMask;
```

Los atributos de restricción especiales son indicadores, y el mismo indicador (GenericParameterAttributes.None) que no representa ninguna restricción especial tampoco representa ninguna covarianza o contravarianza. Por consiguiente, para comprobar cualquiera de estas condiciones, es preciso utilizar la máscara adecuada. En este caso, utilice GenericParameterAttributes.SpecialConstraintMask para aislar los indicadores de restricción especiales.

If sConstraints = GenericParameterAttributes.None Then
    Console.WriteLine("         No special constraints.")
Else
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.DefaultConstructorConstraint) Then
        Console.WriteLine("         Must have a parameterless constructor.")
    End If
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.ReferenceTypeConstraint) Then
        Console.WriteLine("         Must be a reference type.")
    End If
    If GenericParameterAttributes.None <> (sConstraints And _
        GenericParameterAttributes.NotNullableValueTypeConstraint) Then
        Console.WriteLine("         Must be a non-nullable value type.")
    End If
End If

if (sConstraints == GenericParameterAttributes.None)
{
    Console.WriteLine("         No special constraints.");
}
else
{
    if (GenericParameterAttributes.None != (sConstraints &
        GenericParameterAttributes.DefaultConstructorConstraint))
    {
        Console.WriteLine("         Must have a parameterless constructor.");
    }
    if (GenericParameterAttributes.None != (sConstraints &
        GenericParameterAttributes.ReferenceTypeConstraint))
    {
        Console.WriteLine("         Must be a reference type.");
    }
    if (GenericParameterAttributes.None != (sConstraints &
        GenericParameterAttributes.NotNullableValueTypeConstraint))
    {
        Console.WriteLine("         Must be a non-nullable value type.");
    }
}

Construir una instancia de un tipo genérico

Un tipo genérico es como una plantilla. No puede crear instancias del mismo a menos que especifique los tipos reales para sus parámetros de tipo genérico. Hacerlo en tiempo de ejecución, utilizando la reflexión, requiere el método MakeGenericType.

Para construir una instancia de un tipo genérico

Obtiene un objeto Type que representa el tipo genérico. El código siguiente obtiene el tipo genérico Dictionary<TKey, TValue> de dos formas distintas: usando la sobrecarga de método Type.GetType(String) con una cadena que describe el tipo y llamando al método GetGenericTypeDefinition en el tipo construido Dictionary<String, Example> (Dictionary(Of String, Example) en Visual Basic). El método MakeGenericType requiere una definición de tipo genérico.

' Use the GetType operator to create the generic type 
' definition directly. To specify the generic type definition,
' omit the type arguments but retain the comma that separates
' them.
Dim d1 As Type = GetType(Dictionary(Of ,))

' You can also obtain the generic type definition from a
' constructed class. In this case, the constructed class
' is a dictionary of Example objects, with String keys.
Dim d2 As New Dictionary(Of String, Example)
' Get a Type object that represents the constructed type,
' and from that get the generic type definition. The 
' variables d1 and d4 contain the same type.
Dim d3 As Type = d2.GetType()
Dim d4 As Type = d3.GetGenericTypeDefinition()

// Use the typeof operator to create the generic type 
// definition directly. To specify the generic type definition,
// omit the type arguments but retain the comma that separates
// them.
Type d1 = typeof(Dictionary<,>);

// You can also obtain the generic type definition from a
// constructed class. In this case, the constructed class
// is a dictionary of Example objects, with String keys.
Dictionary<string, Example> d2 = new Dictionary<string, Example>();
// Get a Type object that represents the constructed type,
// and from that get the generic type definition. The 
// variables d1 and d4 contain the same type.
Type d3 = d2.GetType();
Type d4 = d3.GetGenericTypeDefinition();

Construya una matriz de argumentos de tipo que sustituir para los parámetros de tipo. La matriz debe contener el número correcto de objetos Type, en el mismo orden en que aparecen en la lista de parámetros de tipo. En este caso, la clave (el primer parámetro de tipo) es del tipo String y los valores incluidos en el diccionario son instancias de una clase denominada Example.
```
Dim typeArgs() As Type = _
    { GetType(String), GetType(Example) }
```
```
Type[] typeArgs = {typeof(string), typeof(Example)};
```
Llame al método MakeGenericType para enlazar los argumentos de tipo a los parámetros de tipo y construir el tipo.
```
Dim constructed As Type = _
    d1.MakeGenericType(typeArgs)
```
```
Type constructed = d1.MakeGenericType(typeArgs);
```
Utilice la sobrecarga de método CreateInstance(Type) para crear un objeto del tipo construido. El código siguiente almacena dos instancias de la clase Example en el objeto Dictionary<String, Example> resultante.
```
Dim o As Object = Activator.CreateInstance(constructed)
```
```
object o = Activator.CreateInstance(constructed);
```

Ejemplo

El ejemplo de código siguiente define un método DisplayGenericType para examinar las definiciones de tipos genéricos y los tipos construidos usados en el código y mostrar su información. El método DisplayGenericType muestra cómo utilizar las propiedades IsGenericType, IsGenericParameter y GenericParameterPosition, y el método GetGenericArguments.

El ejemplo también define un método DisplayGenericParameter para examinar un parámetro de tipo genérico y mostrar sus restricciones.

El ejemplo de código define un conjunto de tipos de prueba, incluido un tipo genérico que ilustra las restricciones de parámetros de tipo, y muestra cómo mostrar información sobre estos tipos.

El ejemplo construye un tipo a partir de la clase Dictionary<TKey, TValue> creando una matriz de argumentos de tipo y llamando al método MakeGenericType. El programa compara el objeto Type construido utilizando MakeGenericType con un objeto Type obtenido mediante typeof (GetType en Visual Basic), para demostrar que son iguales. De forma parecida, el programa utiliza el método GetGenericTypeDefinition para obtener la definición de tipo genérico del tipo construido y lo compara con el objeto Type que representa la clase Dictionary<TKey, TValue>.

Imports System
Imports System.Reflection
Imports System.Collections.Generic
Imports System.Security.Permissions

' Define an example interface.
Public Interface ITestArgument
End Interface

' Define an example base class.
Public Class TestBase
End Class

' Define a generic class with one parameter. The parameter
' has three constraints: It must inherit TestBase, it must
' implement ITestArgument, and it must have a parameterless
' constructor.
Public Class Test(Of T As {TestBase, ITestArgument, New})
End Class

' Define a class that meets the constraints on the type
' parameter of class Test.
Public Class TestArgument
    Inherits TestBase
    Implements ITestArgument
    Public Sub New()
    End Sub
End Class

Public Class Example
    ' The following method displays information about a generic
    ' type.
    Private Shared Sub DisplayGenericType(ByVal t As Type)
        Console.WriteLine(vbCrLf & t.ToString())
        Console.WriteLine("   Is this a generic type? " _ 
            & t.IsGenericType)
        Console.WriteLine("   Is this a generic type definition? " _ 
            & t.IsGenericTypeDefinition)

        ' Get the generic type parameters or type arguments.
        Dim typeParameters() As Type = t.GetGenericArguments()

        Console.WriteLine("   List {0} type arguments:", _
            typeParameters.Length)
        For Each tParam As Type In typeParameters
            If tParam.IsGenericParameter Then
                DisplayGenericParameter(tParam)
            Else
                Console.WriteLine("      Type argument: {0}", _
                    tParam)
            End If
        Next
    End Sub

    ' The following method displays information about a generic
    ' type parameter. Generic type parameters are represented by
    ' instances of System.Type, just like ordinary types.
    Private Shared Sub DisplayGenericParameter(ByVal tp As Type)
        Console.WriteLine("      Type parameter: {0} position {1}", _
            tp.Name, tp.GenericParameterPosition)

        Dim classConstraint As Type = Nothing

        For Each iConstraint As Type In tp.GetGenericParameterConstraints()
            If iConstraint.IsInterface Then
                Console.WriteLine("         Interface constraint: {0}", _
                    iConstraint)
            End If
        Next

        If classConstraint IsNot Nothing Then
            Console.WriteLine("         Base type constraint: {0}", _
                tp.BaseType)
        Else
            Console.WriteLine("         Base type constraint: None")
        End If

        Dim sConstraints As GenericParameterAttributes = _
            tp.GenericParameterAttributes And _
            GenericParameterAttributes.SpecialConstraintMask
        If sConstraints = GenericParameterAttributes.None Then
            Console.WriteLine("         No special constraints.")
        Else
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.DefaultConstructorConstraint) Then
                Console.WriteLine("         Must have a parameterless constructor.")
            End If
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.ReferenceTypeConstraint) Then
                Console.WriteLine("         Must be a reference type.")
            End If
            If GenericParameterAttributes.None <> (sConstraints And _
                GenericParameterAttributes.NotNullableValueTypeConstraint) Then
                Console.WriteLine("         Must be a non-nullable value type.")
            End If
        End If
    End Sub

    <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
    Public Shared Sub Main()
        ' Two ways to get a Type object that represents the generic
        ' type definition of the Dictionary class. 
        '
        ' Use the GetType operator to create the generic type 
        ' definition directly. To specify the generic type definition,
        ' omit the type arguments but retain the comma that separates
        ' them.
        Dim d1 As Type = GetType(Dictionary(Of ,))

        ' You can also obtain the generic type definition from a
        ' constructed class. In this case, the constructed class
        ' is a dictionary of Example objects, with String keys.
        Dim d2 As New Dictionary(Of String, Example)
        ' Get a Type object that represents the constructed type,
        ' and from that get the generic type definition. The 
        ' variables d1 and d4 contain the same type.
        Dim d3 As Type = d2.GetType()
        Dim d4 As Type = d3.GetGenericTypeDefinition()

        ' Display information for the generic type definition, and
        ' for the constructed type Dictionary(Of String, Example).
        DisplayGenericType(d1)
        DisplayGenericType(d2.GetType())

        ' Construct an array of type arguments to substitute for 
        ' the type parameters of the generic Dictionary class.
        ' The array must contain the correct number of types, in 
        ' the same order that they appear in the type parameter 
        ' list of Dictionary. The key (first type parameter)
        ' is of type string, and the type to be contained in the
        ' dictionary is Example.
        Dim typeArgs() As Type = _
            { GetType(String), GetType(Example) }

        ' Construct the type Dictionary(Of String, Example).
        Dim constructed As Type = _
            d1.MakeGenericType(typeArgs)

        DisplayGenericType(constructed)

        Dim o As Object = Activator.CreateInstance(constructed)

        Console.WriteLine(vbCrLf & _
            "Compare types obtained by different methods:")
        Console.WriteLine("   Are the constructed types equal? " _
            & (d2.GetType() Is constructed))
        Console.WriteLine("   Are the generic definitions equal? " _ 
            & (d1 Is constructed.GetGenericTypeDefinition()))

        ' Demonstrate the DisplayGenericType and 
        ' DisplayGenericParameter methods with the Test class 
        ' defined above. This shows base, interface, and special
        ' constraints.
        DisplayGenericType(GetType(Test(Of )))
    End Sub
End Class

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Security.Permissions;

// Define an example interface.
public interface ITestArgument {}

// Define an example base class.
public class TestBase {}

// Define a generic class with one parameter. The parameter
// has three constraints: It must inherit TestBase, it must
// implement ITestArgument, and it must have a parameterless
// constructor.
public class Test<T> where T : TestBase, ITestArgument, new() {}

// Define a class that meets the constraints on the type
// parameter of class Test.
public class TestArgument : TestBase, ITestArgument
{
    public TestArgument() {}
}

public class Example
{
    // The following method displays information about a generic
    // type.
    private static void DisplayGenericType(Type t)
    {
        Console.WriteLine("\r\n {0}", t);
        Console.WriteLine("   Is this a generic type? {0}",
            t.IsGenericType);
        Console.WriteLine("   Is this a generic type definition? {0}",
            t.IsGenericTypeDefinition);

        // Get the generic type parameters or type arguments.
        Type[] typeParameters = t.GetGenericArguments();

        Console.WriteLine("   List {0} type arguments:", 
            typeParameters.Length);
        foreach( Type tParam in typeParameters )
        {
            if (tParam.IsGenericParameter)
            {
                DisplayGenericParameter(tParam);
            }
            else
            {
                Console.WriteLine("      Type argument: {0}",
                    tParam);
            }
        }
    }

    // The following method displays information about a generic
    // type parameter. Generic type parameters are represented by
    // instances of System.Type, just like ordinary types.
    private static void DisplayGenericParameter(Type tp)
    {
        Console.WriteLine("      Type parameter: {0} position {1}", 
            tp.Name, tp.GenericParameterPosition);

        Type classConstraint = null;

        foreach(Type iConstraint in tp.GetGenericParameterConstraints())
        {
            if (iConstraint.IsInterface)
            {
                Console.WriteLine("         Interface constraint: {0}",
                    iConstraint);
            }
        }

        if (classConstraint != null)
        {
            Console.WriteLine("         Base type constraint: {0}", 
                tp.BaseType);
        }
        else
            Console.WriteLine("         Base type constraint: None"); 

        GenericParameterAttributes sConstraints = 
            tp.GenericParameterAttributes & 
            GenericParameterAttributes.SpecialConstraintMask;

        if (sConstraints == GenericParameterAttributes.None)
        {
            Console.WriteLine("         No special constraints.");
        }
        else
        {
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.DefaultConstructorConstraint))
            {
                Console.WriteLine("         Must have a parameterless constructor.");
            }
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.ReferenceTypeConstraint))
            {
                Console.WriteLine("         Must be a reference type.");
            }
            if (GenericParameterAttributes.None != (sConstraints &
                GenericParameterAttributes.NotNullableValueTypeConstraint))
            {
                Console.WriteLine("         Must be a non-nullable value type.");
            }
        }
    }

    [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
    public static void Main()
    {
        // Two ways to get a Type object that represents the generic
        // type definition of the Dictionary class. 
        //
        // Use the typeof operator to create the generic type 
        // definition directly. To specify the generic type definition,
        // omit the type arguments but retain the comma that separates
        // them.
        Type d1 = typeof(Dictionary<,>);

        // You can also obtain the generic type definition from a
        // constructed class. In this case, the constructed class
        // is a dictionary of Example objects, with String keys.
        Dictionary<string, Example> d2 = new Dictionary<string, Example>();
        // Get a Type object that represents the constructed type,
        // and from that get the generic type definition. The 
        // variables d1 and d4 contain the same type.
        Type d3 = d2.GetType();
        Type d4 = d3.GetGenericTypeDefinition();

        // Display information for the generic type definition, and
        // for the constructed type Dictionary<String, Example>.
        DisplayGenericType(d1);
        DisplayGenericType(d2.GetType());

        // Construct an array of type arguments to substitute for 
        // the type parameters of the generic Dictionary class.
        // The array must contain the correct number of types, in 
        // the same order that they appear in the type parameter 
        // list of Dictionary. The key (first type parameter)
        // is of type string, and the type to be contained in the
        // dictionary is Example.
        Type[] typeArgs = {typeof(string), typeof(Example)};

        // Construct the type Dictionary<String, Example>.
        Type constructed = d1.MakeGenericType(typeArgs);

        DisplayGenericType(constructed);

        object o = Activator.CreateInstance(constructed);

        Console.WriteLine("\r\nCompare types obtained by different methods:");
        Console.WriteLine("   Are the constructed types equal? {0}",
            (d2.GetType()==constructed));
        Console.WriteLine("   Are the generic definitions equal? {0}",
            (d1==constructed.GetGenericTypeDefinition()));

        // Demonstrate the DisplayGenericType and 
        // DisplayGenericParameter methods with the Test class 
        // defined above. This shows base, interface, and special
        // constraints.
        DisplayGenericType(typeof(Test<>));
    }
}

Compilar el código

El código contiene las instrucciones using de C# (Imports en Visual Basic) necesarias para la compilación.
No se requiere ninguna referencia de ensamblado adicional.
Compile el código en la línea de comandos usando csc.exe, vbc.exe o cl.exe. Para compilar el código en Visual Studio, colóquelo en la plantilla de proyecto de una aplicación de consola.

Vea también

Cómo: Examinar y crear instancias de tipos genéricos mediante la reflexión

Para examinar un tipo genérico y sus parámetros de tipo

Construir una instancia de un tipo genérico

Para construir una instancia de un tipo genérico

Ejemplo

Compilar el código

Vea también

Conceptos

Referencia

Otros recursos

Recursos adicionales