Como examinar tipos genéricos e criar instâncias deles com a reflexão

 

Informações sobre tipos genéricos são obtidas da mesma forma como informações sobre outros tipos: examinando um Type objeto que representa o tipo genérico. A diferença de princípio é um tipo genérico tem uma lista de Type objetos que representam seus parâmetros de tipo genérico. O primeiro procedimento nesta seção examina os tipos genéricos.

Você pode criar um Type objeto que representa um tipo construído por argumentos de tipo de associação para os parâmetros de tipo de uma definição de tipo genérico. O segundo procedimento demonstra isso.

Para examinar um tipo genérico e seus parâmetros de tipo

  1. Obter uma instância de Type que representa o tipo genérico. No código a seguir, o tipo é obtido usando o c# typeof operador (GetType no Visual Basic, typeid no Visual C++). Consulte o Type tópico de classe para outras maneiras de obter um Type objeto. Observe que no restante deste procedimento, o tipo é contido em um parâmetro do método chamado t.

    Type d1 = typeof(Dictionary<,>);
    
  2. Use o IsGenericType propriedade para determinar se o tipo for genérico e usar o IsGenericTypeDefinition para determinar se o tipo é uma definição de tipo genérico.

    Console.WriteLine("   Is this a generic type? {0}",
        t.IsGenericType);
    Console.WriteLine("   Is this a generic type definition? {0}",
        t.IsGenericTypeDefinition);
    
  3. Obter uma matriz que contém os argumentos de tipo genérico, usando o GetGenericArguments método.

    Type[] typeParameters = t.GetGenericArguments();
    
  4. Para cada argumento de tipo, determinar se ele é um parâmetro de tipo (por exemplo, em uma definição de tipo genérico) ou um tipo que foi especificado para um parâmetro de tipo (por exemplo, em um tipo construído), usando o IsGenericParameter propriedade.

    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);
        }
    }
    
  5. No sistema de tipo, um parâmetro de tipo genérico é representado por uma instância de Type, como tipos comuns são. O código a seguir exibe a posição do nome e o parâmetro de uma Type objeto que representa um parâmetro de tipo genérico. A posição de parâmetro é triviais informações aqui. ele é mais interessante quando você está examinando um parâmetro de tipo que foi usado como um argumento de tipo de outro tipo genérico.

    private static void DisplayGenericParameter(Type tp)
    {
        Console.WriteLine("      Type parameter: {0} position {1}", 
            tp.Name, tp.GenericParameterPosition);
    
  6. Determinar a restrição de tipo base e as restrições de interface de um parâmetro de tipo genérico usando o GetGenericParameterConstraints método para obter todas as restrições em uma única matriz. Não há garantia de que as restrições em uma ordem específica.

    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"); 
    
  7. Use o GenericParameterAttributes propriedade para descobrir as restrições especiais em um parâmetro de tipo, como exigir que ele seja um tipo de referência. A propriedade também inclui valores que representam a variação, que você pode mascarar off, conforme mostrado no código a seguir.

    GenericParameterAttributes sConstraints = 
        tp.GenericParameterAttributes & 
        GenericParameterAttributes.SpecialConstraintMask;
    
  8. Os atributos especiais de restrição são sinalizadores e o mesmo sinalizador (GenericParameterAttributes.None) que não representa nenhum especial restrições também não representa nenhum covariância ou contravariância. Portanto, para testar se há alguma dessas condições, você deve usar a máscara apropriada. Nesse caso, use GenericParameterAttributes.SpecialConstraintMask para isolar os sinalizadores especiais de restrição.

    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.");
        }
    }
    

Um tipo genérico é um modelo. Você não pode criar instâncias dele, a menos que você especifique tipos reais para seus parâmetros de tipo genérico. Para fazer isso em tempo de execução, o uso de reflexão, requer o MakeGenericType método.

Para construir uma instância de um tipo genérico

  1. Obtenha um Type objeto que representa o tipo genérico. O código a seguir obtém o tipo genérico Dictionary<TKey, TValue> de duas maneiras: usando o Type.GetType(String) sobrecarga do método com uma cadeia de caracteres que descreve o tipo e chamando o GetGenericTypeDefinition método no tipo construído Dictionary<String, Example> (Dictionary(Of String, Example) no Visual Basic). O MakeGenericType método requer uma definição de tipo genérico.

    // 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();
    
  2. Construa uma matriz de argumentos de tipo para substituir os parâmetros de tipo. A matriz deve conter o número correto de Type objetos, na mesma ordem em que aparecem na lista de parâmetros de tipo. Nesse caso, a chave (primeiro parâmetro de tipo) é do tipo String, e os valores no dicionário são instâncias de uma classe chamada Example.

    Type[] typeArgs = {typeof(string), typeof(Example)};
    
  3. Chamar o MakeGenericType método para associar os argumentos de tipo para os parâmetros de tipo e construir o tipo.

    Type constructed = d1.MakeGenericType(typeArgs);
    
  4. Use o CreateInstance(Type) sobrecarga de método para criar um objeto do tipo construído. O código a seguir armazena duas instâncias do Example classe resultante Dictionary<String, Example> objeto.

    object o = Activator.CreateInstance(constructed);
    

Exemplo

O exemplo de código a seguir define uma DisplayGenericType método para examinar as definições de tipo genérico e tipos construídos usados no código e exibir suas informações. O DisplayGenericType método mostra como usar o IsGenericType, IsGenericParameter, e GenericParameterPosition Propriedades e o GetGenericArguments método.

O exemplo também define um DisplayGenericParameter método para examinar um parâmetro de tipo genérico e exibir suas restrições.

O exemplo de código define um conjunto de tipos de teste, incluindo um tipo genérico que ilustra as restrições de parâmetro de tipo e mostra como exibir informações sobre esses tipos.

O exemplo a seguir constrói um tipo a partir de Dictionary<TKey, TValue> classe, criando uma matriz de argumentos de tipo e chamando o MakeGenericType método. Compara o programa de Type objeto criado usando MakeGenericType com um Type objeto obtido usando typeof (GetType no Visual Basic), demonstrando que eles são os mesmos. Da mesma forma, o programa usa o GetGenericTypeDefinition método para obter a definição de tipo genérico do tipo construído e o compara a Type objeto representando o Dictionary<TKey, TValue> classe.

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<>));
    }
}

Compilando o Código

  • Contém o código c# using instruções (Imports no Visual Basic) necessária para compilação.

  • Nenhuma referência de assembly adicionais é necessária.

  • Compile o código na linha de comando usando csc.exe, vbc.exe ou cl.exe. Para compilar o código no Visual Studio, coloque-o em um modelo de projeto de aplicativo do console.

Mostrar: