如何使用反射调用泛型方法？

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

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

对于静态方法，将 null 作为第一个参数传递给 Invoke。这与泛型方法无关——它只是正常的反射。

如前所述，从使用 dynamic 的 C# 4 开始，其中很多内容都更简单——当然，如果您可以使用类型推断。在类型推断不可用的情况下（例如问题中的确切示例），它没有帮助。

---

只是对原始答案的补充。虽然这会起作用：

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 类的实例）中知道类型。否则，您必须创建该类型的对象或使用标准反射 API solution。您可以使用 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 运算符）。

通过将对象参数转换为 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 中的 caching 机制，下一次使用相同类型的参数调用应该更快。当然，您可以编写缓存调用的委托的代码，但是通过使用 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 中将参数作为对象数组提供，则不会发生这种情况。

下面是一个简单的示例，说明了如何在编译时（注释代码）和运行时捕获其他错误。它还显示了 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 参数传递给方法时，此调用为 lately bound。方法重载解析发生在运行时并尝试选择最佳重载。因此，如果您使用 BarItem 类型的对象调用 ProcessItem 方法，那么您实际上将调用非泛型方法，因为它更适合这种类型。但是，当您传递 Alpha 类型的参数时会出现运行时错误，因为没有可以处理此对象的方法（通用方法具有约束 where T : IItem 并且 Alpha 类不实现此接口）。但这就是重点。编译器没有此调用有效的信息。作为程序员的你知道这一点，你应该确保这段代码运行没有错误。

返回类型陷阱

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

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

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

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

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

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

---

添加到 Adrian Gallero's answer：

从类型信息调用泛型方法涉及三个步骤。

##TLDR：使用类型对象调用已知的泛型方法可以通过以下方式完成：##

((Action)GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition()
    .MakeGenericMethod(typeof(string))
    .Invoke(this, null);

其中 GenericMethod<object> 是要调用的方法名称和任何满足通用约束的类型。

(Action) 匹配要调用的方法的签名，即（Func<string,string,int> 或 Action<bool>）

##Step 1 正在获取泛型方法定义的 MethodInfo##

###Method 1：使用带有适当类型或绑定标志的 GetMethod() 或 GetMethods()。###

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");

###Method 2：创建委托，获取MethodInfo对象，然后调用GetGenericMethodDefinition

从包含方法的类内部：

MethodInfo method = ((Action)GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition();

MethodInfo method = ((Action)StaticMethod<object>)
    .Method
    .GetGenericMethodDefinition();

从包含方法的类外部：

MethodInfo method = ((Action)(new Sample())
    .GenericMethod<object>)
    .Method
    .GetGenericMethodDefinition();

MethodInfo method = ((Action)Sample.StaticMethod<object>)
    .Method
    .GetGenericMethodDefinition();

在C#中，方法的名称，即“ToString”或“GenericMethod”实际上是指一组方法，其中可能包含一个或多个方法。在您提供方法参数的类型之前，不知道您指的是哪种方法。

((Action)GenericMethod<object>) 指代特定方法的委托。 ((Func<string, int>)GenericMethod<object>) 指的是不同的 GenericMethod 重载

###Method 3：创建一个包含方法调用表达式的lambda表达式，获取MethodInfo对象然后GetGenericMethodDefinition

MethodInfo method = ((MethodCallExpression)((Expression<Action<Sample>>)(
    (Sample v) => v.GenericMethod<object>()
    )).Body).Method.GetGenericMethodDefinition();

这分解为

创建一个 lambda 表达式，其中主体是对所需方法的调用。

Expression<Action<Sample>> expr = (Sample v) => v.GenericMethod<object>();

提取主体并转换为 MethodCallExpression

MethodCallExpression methodCallExpr = (MethodCallExpression)expr.Body;

从方法中获取泛型方法定义

MethodInfo methodA = methodCallExpr.Method.GetGenericMethodDefinition();

##Step 2 正在调用 MakeGenericMethod 以创建具有适当类型的泛型方法。##

MethodInfo generic = method.MakeGenericMethod(myType);

##Step 3 使用适当的参数调用方法。##

generic.Invoke(this, null);

---

在 C# 4.0 中，不需要反射，因为 DLR 可以使用运行时类型调用它。由于动态使用 DLR 库有点痛苦（而不是 C# 编译器为您生成代码），因此开源框架 Dynamitey（.net 标准 1.5）让您可以轻松地缓存运行时访问编译器的相同调用会为你生成。

var name = InvokeMemberName.Create;
Dynamic.InvokeMemberAction(this, name("GenericMethod", new[]{myType}));


var staticContext = InvokeContext.CreateStatic;
Dynamic.InvokeMemberAction(staticContext(typeof(Sample)), name("StaticMethod", new[]{myType}));

---

没有人提供“经典反射”解决方案，所以这里是一个完整的代码示例：

using System;
using System.Collections;
using System.Collections.Generic;

namespace DictionaryRuntime
{
    public class DynamicDictionaryFactory
    {
        /// <summary>
        /// Factory to create dynamically a generic Dictionary.
        /// </summary>
        public IDictionary CreateDynamicGenericInstance(Type keyType, Type valueType)
        {
            //Creating the Dictionary.
            Type typeDict = typeof(Dictionary<,>);

            //Creating KeyValue Type for Dictionary.
            Type[] typeArgs = { keyType, valueType };

            //Passing the Type and create Dictionary Type.
            Type genericType = typeDict.MakeGenericType(typeArgs);

            //Creating Instance for Dictionary<K,T>.
            IDictionary d = Activator.CreateInstance(genericType) as IDictionary;

            return d;

        }
    }
}

上面的 DynamicDictionaryFactory 类有一个方法

CreateDynamicGenericInstance(Type keyType, Type valueType)

它创建并返回一个 IDictionary 实例，其键和值的类型正是在调用 keyType 和 valueType 中指定的。

这是一个完整的示例如何调用此方法来实例化和使用 Dictionary<String, int>：

using System;
using System.Collections.Generic;

namespace DynamicDictionary
{
    class Test
    {
        static void Main(string[] args)
        {
            var factory = new DictionaryRuntime.DynamicDictionaryFactory();
            var dict = factory.CreateDynamicGenericInstance(typeof(String), typeof(int));

            var typedDict = dict as Dictionary<String, int>;

            if (typedDict != null)
            {
                Console.WriteLine("Dictionary<String, int>");

                typedDict.Add("One", 1);
                typedDict.Add("Two", 2);
                typedDict.Add("Three", 3);

                foreach(var kvp in typedDict)
                {
                    Console.WriteLine("\"" + kvp.Key + "\": " + kvp.Value);
                }
            }
            else
                Console.WriteLine("null");
        }
    }
}

当执行上述控制台应用程序时，我们得到了正确的预期结果：

Dictionary<String, int>
"One": 1
"Two": 2
"Three": 3

---

这是我基于 Grax's answer 的 2 美分，但有两个泛型方法所需的参数。

假设您的方法在 Helpers 类中定义如下：

public class Helpers
{
    public static U ConvertCsvDataToCollection<U, T>(string csvData)
    where U : ObservableCollection<T>
    {
      //transform code here
    }
}

在我的例子中，U 类型始终是存储 T 类型对象的可观察集合。

由于我已经预定义了类型，我首先创建了代表可观察集合 (U) 和存储在其中的对象 (T) 的“虚拟”对象，这些对象将在下面调用 Make 时用于获取它们的类型

object myCollection = Activator.CreateInstance(collectionType);
object myoObject = Activator.CreateInstance(objectType);

然后调用 GetMethod 来查找您的通用函数：

MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");

到目前为止，上面的调用与上面解释的几乎相同，但是当你需要向它传递多个参数时会有一点不同。

您需要将 Type[] 数组传递给包含上面创建的“虚拟”对象类型的 MakeGenericMethod 函数：

MethodInfo generic = method.MakeGenericMethod(
new Type[] {
   myCollection.GetType(),
   myObject.GetType()
});

完成后，您需要调用上面提到的 Invoke 方法。

generic.Invoke(null, new object[] { csvData });

你完成了。很有魅力！

更新：

正如@Bevan 强调的那样，在调用 MakeGenericMethod 函数时我不需要创建一个数组，因为它需要参数，我不需要创建一个对象来获取类型，因为我可以直接将类型传递给这个函数。就我而言，由于我在另一个类中预定义了类型，我只是将代码更改为：

object myCollection = null;

MethodInfo method = typeof(Helpers).
GetMethod("ConvertCsvDataToCollection");

MethodInfo generic = method.MakeGenericMethod(
   myClassInfo.CollectionType,
   myClassInfo.ObjectType
);

myCollection = generic.Invoke(null, new object[] { csvData });

myClassInfo 包含 2 个类型为 Type 的属性，我在运行时根据传递给构造函数的枚举值设置它们，并将为我提供相关类型，然后我将在 MakeGenericMethod 中使用这些类型。

再次感谢您强调此@Bevan。

---

受 Enigmativity's answer 启发 - 假设您有两个（或更多）类，例如

public class Bar { }
public class Square { }

并且您想用 Bar 和 Square 调用方法 Foo<T>，它被声明为

public class myClass
{
    public void Foo<T>(T item)
    {
        Console.WriteLine(typeof(T).Name);
    }
}

然后你可以实现一个扩展方法，如：

public static class Extension
{
    public static void InvokeFoo<T>(this T t)
    {
        var fooMethod = typeof(myClass).GetMethod("Foo");
        var tType = typeof(T);
        var fooTMethod = fooMethod.MakeGenericMethod(new[] { tType });
        fooTMethod.Invoke(new myClass(), new object[] { t });
    }
}

有了这个，您可以像这样简单地调用 Foo：

var objSquare = new Square();
objSquare.InvokeFoo();

var objBar = new Bar();
objBar.InvokeFoo();

适用于每个班级。在这种情况下，它将输出：

方形酒吧

---