当在编译时未知类型参数但是在运行时动态获取时，调用泛型方法的最佳方法是什么？

考虑以下示例代码 - 在Example()方法中，使用存储在myType变量中的Type调用GenericMethod<T>()的最简洁方法是什么？

public class Sample
{
    public void Example(string typeName)
    {
        Type myType = FindType(typeName);

        // What goes here to call GenericMethod<T>()?
        GenericMethod<myType>(); // This doesn't work

        // What changes to call StaticMethod<T>()?
        Sample.StaticMethod<myType>(); // This also doesn't work
    }

    public void GenericMethod<T>()
    {
        // ...
    }

    public static void StaticMethod<T>()
    {
        //...
    }
}

您需要使用反射来获取方法，然后通过使用MakeGenericMethod提供类型参数来 “构造” 它：

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);

对于静态方法，将null作为Invoke的第一个参数传递。这与通用方法无关 - 它只是普通的反射。

如上所述，当 C＃4 使用dynamic ，很多这个更简单 - 当然，如果你可以使用类型推断。在类型推断不可用的情况下（例如问题中的确切示例），它没有帮助。

只是对原始答案的补充。虽然这将工作：

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);

它也有点危险，因为你失去了GenericMethod编译时检查。如果您稍后进行重构并重命名GenericMethod ，则此代码将不会注意到并且将在运行时失败。此外，如果对程序集进行任何后处理（例如，混淆或删除未使用的方法 / 类），则此代码也可能会中断。

所以，如果你知道你在编译时链接到的方法，并且这不会被调用数百万次因此开销无关紧要，我会将此代码更改为：

Action<> GenMethod = GenericMethod<int>;  //change int by any base type 
                                          //accepted by GenericMethod
MethodInfo method = this.GetType().GetMethod(GenMethod.Method.Name);
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);

虽然不是很漂亮，但你在这里有一个GenericMethod的编译时引用，如果你使用GenericMethod重构，删除或做任何事情，这段代码将继续工作，或者至少在编译时中断（例如你删除GenericMethod ）。

执行相同操作的其他方法是创建一个新的包装类，并通过Activator创建它。我不知道是否有更好的方法。

通过使用dynamic类型而不是反射 API，可以极大地简化使用仅在运行时知道的类型参数调用泛型方法。

要使用此技术，必须从实际对象（而不仅仅是Type类的实例）中Type 。否则，您必须创建该类型的对象或使用标准反射 API 解决方案 。您可以使用Activator.CreateInstance方法创建对象。

如果你想调用泛型方法，那么在 “正常” 用法中会推断出它的类型，那么它只是将未知类型的对象转换为dynamic 。这是一个例子：

class Alpha { }
class Beta { }
class Service
{
    public void Process<T>(T item)
    {
        Console.WriteLine("item.GetType(): " + item.GetType()
                          + "\ttypeof(T): " + typeof(T));
    }
}

class Program
{
    static void Main(string[] args)
    {
        var a = new Alpha();
        var b = new Beta();

        var service = new Service();
        service.Process(a); // Same as "service.Process<Alpha>(a)"
        service.Process(b); // Same as "service.Process<Beta>(b)"

        var objects = new object[] { a, b };
        foreach (var o in objects)
        {
            service.Process(o); // Same as "service.Process<object>(o)"
        }
        foreach (var o in objects)
        {
            dynamic dynObj = o;
            service.Process(dynObj); // Or write "service.Process((dynamic)o)"
        }
    }
}

以下是该程序的输出：

item.GetType(): Alpha    typeof(T): Alpha
item.GetType(): Beta     typeof(T): Beta
item.GetType(): Alpha    typeof(T): System.Object
item.GetType(): Beta     typeof(T): System.Object
item.GetType(): Alpha    typeof(T): Alpha
item.GetType(): Beta     typeof(T): Beta

Process是一个通用实例方法，它写入传递参数的实际类型（通过使用GetType()方法）和泛型参数的类型（通过使用typeof运算符）。

通过将 object 参数转换为dynamic类型，我们延迟提供类型参数直到运行时。使用dynamic参数调用Process方法时，编译器不关心此参数的类型。编译器生成的代码在运行时检查传递的参数的实际类型（通过使用反射）并选择要调用的最佳方法。这里只有一个通用方法，所以用适当的类型参数调用它。

在此示例中，输出与您编写的内容相同：

foreach (var o in objects)
{
    MethodInfo method = typeof(Service).GetMethod("Process");
    MethodInfo generic = method.MakeGenericMethod(o.GetType());
    generic.Invoke(service, new object[] { o });
}

具有动态类型的版本肯定更短且更容易编写。您也不必担心多次调用此函数的性能。由于 DLR 中的缓存机制，具有相同类型的参数的下一个调用应该更快。当然，您可以编写缓存调用的委托的代码，但通过使用dynamic类型，您可以免费获得此行为。

如果要调用的泛型方法没有参数化类型的参数（因此无法推断其类型参数），那么可以将循环方法的调用包装在辅助方法中，如下例所示：

class Program
{
    static void Main(string[] args)
    {
        object obj = new Alpha();

        Helper((dynamic)obj);
    }

    public static void Helper<T>(T obj)
    {
        GenericMethod<T>();
    }

    public static void GenericMethod<T>()
    {
        Console.WriteLine("GenericMethod<" + typeof(T) + ">");
    }
}

增加了类型安全性

使用dynamic对象替代使用反射 API 的真正好处在于，您只会丢失在运行时之前不知道的特定类型的编译时检查。其他参数和方法的名称由编译器照常静态分析。如果删除或添加更多参数，更改其类型或重命名方法名称，则会出现编译时错误。如果在Type.GetMethod中将方法名称作为字符串提供，并且在MethodInfo.Invoke中将参数作为 objects 数组提供，则不会发生这种情况。

下面是一个简单的示例，说明了如何在编译时（注释代码）和其他运行时捕获某些错误。它还显示了 DLR 如何尝试解析要调用的方法。

interface IItem { }
class FooItem : IItem { }
class BarItem : IItem { }
class Alpha { }

class Program
{
    static void Main(string[] args)
    {
        var objects = new object[] { new FooItem(), new BarItem(), new Alpha() };
        for (int i = 0; i < objects.Length; i++)
        {
            ProcessItem((dynamic)objects[i], "test" + i, i);

            //ProcesItm((dynamic)objects[i], "test" + i, i);
            //compiler error: The name 'ProcesItm' does not
            //exist in the current context

            //ProcessItem((dynamic)objects[i], "test" + i);
            //error: No overload for method 'ProcessItem' takes 2 arguments
        }
    }

    static string ProcessItem<T>(T item, string text, int number)
        where T : IItem
    {
        Console.WriteLine("Generic ProcessItem<{0}>, text {1}, number:{2}",
                          typeof(T), text, number);
        return "OK";
    }
    static void ProcessItem(BarItem item, string text, int number)
    {
        Console.WriteLine("ProcessItem with Bar, " + text + ", " + number);
    }
}

这里我们再次通过将参数强制转换为dynamic类型来执行某些方法。只有第一个参数类型的验证才会推迟到运行时。如果您正在调用的方法的名称不存在或者其他参数无效（参数数量错误或类型错误），则会出现编译器错误。

将dynamic参数传递给方法时，此调用最近被绑定 。方法重载解析在运行时发生并尝试选择最佳过载。因此，如果您使用BarItem类型的对象调用ProcessItem方法，那么您实际上将调用非泛型方法，因为它更适合此类型。但是，当您传递Alpha类型的参数时，您将收到运行时错误，因为没有可以处理此对象的方法（泛型方法具有where T : IItem和Alpha类不实现此接口的约束）。但这就是重点。编译器没有此调用有效的信息。作为程序员，你知道这一点，你应该确保这段代码运行没有错误。

返回类型了

当您使用动态类型的参数调用非 void 方法时，其返回类型也可能是dynamic 。因此，如果您将以前的示例更改为此代码：

var result = ProcessItem((dynamic)testObjects[i], "test" + i, i);

那么结果对象的类型就是dynamic 。这是因为编译器并不总是知道将调用哪个方法。如果你知道函数调用的返回类型，那么你应该隐式地将它转换为所需的类型，所以其余的代码是静态类型的：

string result = ProcessItem((dynamic)testObjects[i], "test" + i, i);

如果类型不匹配，您将收到运行时错误。

实际上，如果您尝试在前一个示例中获取结果值，那么您将在第二个循环迭代中获得运行时错误。这是因为您尝试保存 void 函数的返回值。