Pase un sistema instanciado. Escriba como parámetro de tipo para una clase genérica

El título es un poco oscuro. Lo que quiero saber es si esto es posible:

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

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

Obviamente, MyGenericClass se describe como:

public class MyGenericClass<T>

En este momento, el compilador se queja de que 'El tipo o espacio de nombres' myType 'no se pudo encontrar ". Tiene que haber una manera de hacerlo.

No puedes hacer esto sin reflexionar. Sin embargo, usted puede hacerlo con la reflexión. Aquí hay un ejemplo 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: si su clase genérica acepta varios tipos, debe incluir las comas cuando omita los nombres de los tipos, por ejemplo:

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

Lamentablemente no, no hay. Los argumentos genéricos deben poder resolverse en tiempo de compilación como 1) un tipo válido u 2) otro parámetro genérico. No hay forma de crear instancias genéricas basadas en valores de tiempo de ejecución sin el gran martillo de usar la reflexión.

Algunas formas adicionales de ejecutar con código de tijera. Supongamos que tienes una clase similar a

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

Supongamos que en tiempo de ejecución tienes un FooContent

Si pudieras enlazar en tiempo de compilación, querrías

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

Sin embargo, no puede hacer esto en tiempo de ejecución. Para hacer esto en tiempo de ejecución, haría lo siguiente:

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

Invocar dinámicamente Markdown(IEnumerable<FooContent> contents)

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

Tenga en cuenta el uso de dynamicen la llamada al método. En el tiempo de ejecución dynamicListserá List<FooContent>(además de serlo IEnumerable<FooContent>), ya que incluso el uso de la dinámica todavía está enraizado en un lenguaje fuertemente tipado, el enlazador de tiempo de ejecución seleccionará el Markdownmétodo apropiado . Si no hay coincidencias de tipo exactas, buscará un método de parámetro de objeto y si ninguna coincide, se generará una excepción de carpeta de tiempo de ejecución alertando que ningún método coincide.

El inconveniente obvio de este enfoque es una gran pérdida de seguridad de tipo en tiempo de compilación. Sin embargo, el código a lo largo de estas líneas le permitirá operar en un sentido muy dinámico que en tiempo de ejecución todavía está completamente escrito como espera que sea.

Mis requisitos eran ligeramente diferentes, pero espero que ayuden a alguien. Necesitaba leer el tipo de una configuración e instanciar el tipo genérico dinámicamente.

namespace GenericTest
{
    public class Item
    {
    }
}

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

Finalmente, así es como lo llamas. Defina el tipo con un backtick .

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

Si sabe qué tipos se pasarán, puede hacerlo sin reflexionar. Una declaración de cambio funcionaría. Obviamente, esto solo funcionaría en un número limitado de casos, pero será mucho más rápido que la reflexión.

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

En este fragmento, quiero mostrar cómo crear y usar una lista creada dinámicamente. Por ejemplo, estoy agregando a la lista dinámica aquí.

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

Del mismo modo, puede invocar cualquier otro método en la lista.