Przekaż instancyjny System.Type jako parametr typu dla klasy ogólnej

Tytuł jest niejasny. Chcę wiedzieć, czy jest to możliwe:

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

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

Oczywiście MyGenericClass jest opisany jako:

public class MyGenericClass<T>

W tej chwili kompilator narzeka, że ​​„Nie można znaleźć typu lub przestrzeni nazw„ myType ”.” Musi być na to sposób.

Nie możesz tego zrobić bez refleksji. Jednakże, można zrobić to z refleksji. Oto kompletny przykład:

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

Uwaga: jeśli twoja klasa ogólna akceptuje wiele typów, musisz pominąć przecinki, pomijając nazwy typów, na przykład:

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

Niestety nie, nie ma. Argumenty ogólne muszą być rozwiązywalne w czasie kompilacji jako 1) prawidłowy typ lub 2) inny parametr ogólny. Nie ma sposobu na utworzenie ogólnych instancji w oparciu o wartości środowiska wykonawczego bez dużego młota przy użyciu odbicia.

Dodatkowe informacje na temat uruchamiania przy użyciu kodu nożyczek. Załóżmy, że masz klasę podobną do

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

Załóżmy, że w czasie wykonywania masz FooContent

Gdybyś mógł powiązać w czasie kompilacji, chciałbyś

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

Jednak nie można tego zrobić w czasie wykonywania. Aby to zrobić w środowisku wykonawczym, wykonaj następujące czynności:

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

Aby dynamicznie wywoływać Markdown(IEnumerable<FooContent> contents)

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

Zwróć uwagę na użycie dynamicw wywołaniu metody. W czasie wykonywania dynamicListbędzie List<FooContent>(dodatkowo również IEnumerable<FooContent>), ponieważ nawet użycie dynamiki jest nadal zakorzenione w silnie typowanym języku, spoiwo w czasie wykonywania wybierze odpowiednią Markdownmetodę. Jeśli nie ma dokładnych dopasowań typu, będzie szukał metody parametru obiektowego, a jeśli nie będzie pasował żaden wyjątek spoiwa środowiska wykonawczego, pojawi się ostrzeżenie, że żadna metoda nie pasuje.

Oczywistą wadą tego podejścia jest ogromna utrata bezpieczeństwa typu w czasie kompilacji. Niemniej jednak kod zgodny z tymi liniami pozwoli ci działać w bardzo dynamiczny sposób, że w środowisku wykonawczym jest nadal w pełni wpisany, tak jak się spodziewasz.

Moje wymagania były nieco inne, ale mam nadzieję, że komuś pomogą. Musiałem odczytać typ z konfiguracji i dynamicznie utworzyć instancję typu ogólnego.

namespace GenericTest
{
    public class Item
    {
    }
}

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

Wreszcie, jak to nazywasz. Zdefiniuj typ za pomocą przycisku wstecz .

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

Jeśli wiesz, jakie typy zostaną zaliczone, możesz to zrobić bez refleksji. Instrukcja switch działałaby. Oczywiście działałoby to tylko w ograniczonej liczbie przypadków, ale będzie znacznie szybsze niż refleksja.

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

W tym fragmencie chcę pokazać, jak utworzyć i używać dynamicznie tworzonej listy. Na przykład dodaję tutaj listę dynamiczną.

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

Podobnie możesz wywołać dowolną inną metodę z listy.