这是我基于Grax的回答的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找到你的Generic函数:

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个类型类型的属性，我在运行时根据传递给构造函数的枚举值设置，并将为我提供相关类型，然后在MakeGenericMethod中使用。

再次感谢你强调这个@Bevan。

这是我基于Grax的回答的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找到你的Generic函数:

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个类型类型的属性，我在运行时根据传递给构造函数的枚举值设置，并将为我提供相关类型，然后在MakeGenericMethod中使用。

再次感谢你强调这个@Bevan。

受Enigmativity的答案启发-让我们假设你有两个(或更多)类，比如

public class Bar { }
public class Square { }

你想调用方法Foo<T> with Bar and Square，它被声明为

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

然后你可以实现一个Extension方法:

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

这对每个类都适用。在这种情况下，它将输出:

广场 酒吧

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

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

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

如上所述，在使用动态的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创建它。我不知道有没有更好的办法。

在c# 4.0中，反射是不必要的，因为DLR可以使用运行时类型调用它。由于动态地使用DLR库有点麻烦(而不是c#编译器为您生成代码)，开源框架Dynamitey (.net standard 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}));