Passe um System.Type instanciado como um parâmetro de tipo para uma classe genérica

O título é meio obscuro. O que eu quero saber é se isso é possível:

string typeName = <read type name from somwhere>;
Type myType = Type.GetType(typeName);

MyGenericClass<myType> myGenericClass = new MyGenericClass<myType>();

Obviamente, MyGenericClass é descrito como:

public class MyGenericClass<T>

No momento, o compilador reclama que 'O tipo ou espaço de nome' myType 'não foi encontrado. "É preciso haver uma maneira de fazer isso.

Você não pode fazer isso sem reflexão. No entanto, você pode fazer isso com reflexão. Aqui está um exemplo completo:

using System;
using System.Reflection;

public class Generic<T>
{
    public Generic()
    {
        Console.WriteLine("T={0}", typeof(T));
    }
}

class Test
{
    static void Main()
    {
        string typeName = "System.String";
        Type typeArgument = Type.GetType(typeName);

        Type genericClass = typeof(Generic<>);
        // MakeGenericType is badly named
        Type constructedClass = genericClass.MakeGenericType(typeArgument);

        object created = Activator.CreateInstance(constructedClass);
    }
}

Nota: se sua classe genérica aceitar vários tipos, você deverá incluir vírgulas ao omitir os nomes dos tipos, por exemplo:

Type genericClass = typeof(IReadOnlyDictionary<,>);
Type constructedClass = genericClass.MakeGenericType(typeArgument1, typeArgument2);

Infelizmente não, não existe. Os argumentos genéricos devem ser resolvidos no momento da compilação como 1) um tipo válido ou 2) outro parâmetro genérico. Não há como criar instâncias genéricas baseadas em valores de tempo de execução sem o grande martelo de usar a reflexão.

Algumas dicas adicionais sobre como executar com o código de tesoura. Suponha que você tenha uma classe semelhante a

public class Encoder() {
public void Markdown(IEnumerable<FooContent> contents) { do magic }
public void Markdown(IEnumerable<BarContent> contents) { do magic2 }
}

Suponha que, em tempo de execução, você tenha um FooContent

Se você fosse capaz de ligar em tempo de compilação, desejaria

var fooContents = new List<FooContent>(fooContent)
new Encoder().Markdown(fooContents)

No entanto, você não pode fazer isso em tempo de execução. Para fazer isso em tempo de execução, faça o seguinte:

var listType = typeof(List<>).MakeGenericType(myType);
var dynamicList = Activator.CreateInstance(listType);
((IList)dynamicList).Add(fooContent);

Para chamar dinamicamente Markdown(IEnumerable<FooContent> contents)

new Encoder().Markdown( (dynamic) dynamicList)

Observe o uso de dynamicna chamada de método. No tempo de execução, dynamicListhaverá List<FooContent>(adicionalmente também sendo IEnumerable<FooContent>), pois mesmo o uso de dinâmico ainda está enraizado em uma linguagem fortemente tipada, o fichário de tempo de execução selecionará o Markdownmétodo apropriado . Se não houver correspondências exatas de tipo, ele procurará um método de parâmetro de objeto e se nenhuma delas corresponder a uma exceção do fichário de tempo de execução será gerada, alertando que nenhum método corresponde.

A desvantagem óbvia dessa abordagem é uma enorme perda de segurança de tipo em tempo de compilação. No entanto, o código nesse sentido permitirá operar em um sentido muito dinâmico, que no tempo de execução ainda é totalmente digitado conforme o esperado.

Meus requisitos eram um pouco diferentes, mas espero ajudar alguém. Eu precisava ler o tipo de uma configuração e instanciar o tipo genérico dinamicamente.

namespace GenericTest
{
    public class Item
    {
    }
}

namespace GenericTest
{
    public class GenericClass<T>
    {
    }
}

Finalmente, aqui está como você chama. Defina o tipo com um backtick .

var t = Type.GetType("GenericTest.GenericClass`1[[GenericTest.Item, GenericTest]], GenericTest");
var a = Activator.CreateInstance(t);

Se você souber quais tipos serão passados, poderá fazer isso sem reflexão. Uma declaração de chave funcionaria. Obviamente, isso funcionaria apenas em um número limitado de casos, mas será muito mais rápido que a reflexão.

public class Type1 { }

public class Type2 { }

public class Generic<T> { }

public class Program
{
    public static void Main()
    {
        var typeName = nameof(Type1);

        switch (typeName)
        {
            case nameof(Type1):
                var type1 = new Generic<Type1>();
                // do something
                break;
            case nameof(Type2):
                var type2 = new Generic<Type2>();
                // do something
                break;
        }
    }
}

Neste snippet, quero mostrar como criar e usar uma lista criada dinamicamente. Por exemplo, estou adicionando à lista dinâmica aqui.

void AddValue<T>(object targetList, T valueToAdd)
{
    var addMethod = targetList.GetType().GetMethod("Add");
    addMethod.Invoke(targetList, new[] { valueToAdd } as object[]);
}

var listType = typeof(List<>).MakeGenericType(new[] { dynamicType }); // dynamicType is the type you want
var list = Activator.CreateInstance(listType);

AddValue(list, 5);

Da mesma forma, você pode invocar qualquer outro método na lista.