传递实例化的System.Type作为泛型类的类型参数

标题有点晦涩。我想知道的是这是否可能：

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

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

显然，MyGenericClass被描述为：

public class MyGenericClass<T>

现在，编译器抱怨“找不到类型或名称空间“ myType”。”必须有一种方法可以做到这一点。

您不能没有反思。但是，您可以通过反射来实现。这是一个完整的示例：

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

注意：如果泛型类接受多种类型，则在省略类型名称时必须包含逗号，例如：

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

不幸的是，没有。泛型参数在编译时必须可解析为1）有效类型或2）另一个泛型参数。没有使用反射的大力支持，就无法基于运行时值创建通用实例。

其他一些如何使用剪刀代码运行的方法。假设您有一个类似于

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

假设在运行时您有一个FooContent

如果您能够在编译时进行绑定，则需要

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

但是，您无法在运行时执行此操作。要在运行时执行此操作，应遵循以下步骤：

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

动态调用 Markdown(IEnumerable<FooContent> contents)

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

注意dynamic方法调用中的用法。在运行时dynamicList将List<FooContent>（另外也是IEnumerable<FooContent>），因为即使对dynamic的使用仍然植根于强类型语言，运行时绑定程序也会选择适当的Markdown方法。如果没有完全匹配的类型，它将查找对象参数方法，如果都不匹配，则会引发运行时绑定程序异常，警告没有方法匹配。

这种方法的明显缺点是在编译时会大大损失类型安全性。尽管如此，沿着这些行的代码将使您以非常动态的方式进行操作，即在运行时仍按您期望的方式完全键入。

我的要求略有不同，但希望会对您有所帮助。我需要从配置中读取类型并动态实例化泛型。

namespace GenericTest
{
    public class Item
    {
    }
}

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

最后，这是您的称呼方式。使用反引号定义类型。

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

如果您知道将传递哪种类型，则可以进行反射。switch语句将起作用。显然，这仅在少数情况下有效，但是它比反射要快得多。

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

在此片段中，我想展示如何创建和使用动态创建的列表。例如，我要在此处添加动态列表。

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

同样，您可以调用列表上的任何其他方法。