14

给定

public Class Example
{

public static void Foo< T>(int ID){}

public static void Foo< T,U>(int ID){}

}

问题：

  1. 将其称为“重载的泛型方法”是否正确？

  2. 如何在创建 MethodInfo 对象时指定这两种方法？ 

    Type exampleType = Type.GetType("fullyqualifiednameOfExample, namespaceOfExample");
MethodInfo mi = exampleType.GetMethod("Foo", BindingFlags.Public|BindingFlags.Static, null, new Type[] {typeof(Type), typeof(Type) }, null);

参数 4 导致编译器非常不满

4

6 回答 6

14

我找不到一种使用 GetMethod 的方法来做你想做的事。但是您可以获取所有方法并遍历列表，直到找到您想要的方法。

请记住，您需要先调用 MakeGenericMethod，然后才能实际使用它。

var allMethods = typeof (Example).GetMethods(BindingFlags.Public | BindingFlags.Static);
MethodInfo foundMi = allMethods.FirstOrDefault(
    mi => mi.Name == "Foo" && mi.GetGenericArguments().Count() == 2);
if (foundMi != null)
{
    MethodInfo closedMi = foundMi.MakeGenericMethod(new Type[] {typeof (int), typeof (string)});
    Example example= new Example();
    closedMi.Invoke(example, new object[] { 5 });
}
于 2009-02-25T22:29:01.677 回答
4

以下是您的问题的答案以及示例：

  1. 是的，尽管对于泛型方法，类型推断和重载方法解析确实需要注意两件事。在编译器尝试解析重载的方法签名之前，类型推断发生在编译时。编译器将类型推断逻辑应用于所有具有相同名称的泛型方法。在重载决策步骤中，编译器仅包括类型推断成功的那些泛型方法。 更多在这里...

  2. 请参阅下面的完整示例控制台应用程序代码，该代码显示了如何在创建 MethodInfo 对象时指定 Foo 方法的几个变体，然后使用 Extension 方法调用：

程序.cs

class Program
{
    static void Main(string[] args)
    {
        MethodInfo foo1 = typeof(Example).GetGenericMethod("Foo",
            new[] { typeof(string) },
            new[] { typeof(int) },
            typeof(void));

        MethodInfo foo2 = typeof(Example).GetGenericMethod("Foo",
            new[] { typeof(string), typeof(int) },
            new[] { typeof(int) },
            typeof(void));

        MethodInfo foo3 = typeof(Example).GetGenericMethod("Foo",
            new[] { typeof(string) },
            new[] { typeof(string) },
            typeof(void));

        MethodInfo foo4 = typeof(Example).GetGenericMethod("Foo",
            new[] { typeof(string), typeof(int) },
            new[] { typeof(int), typeof(string) },
            typeof(string));

        Console.WriteLine(foo1.Invoke(null, new object[] { 1 }));
        Console.WriteLine(foo2.Invoke(null, new object[] { 1 }));
        Console.WriteLine(foo3.Invoke(null, new object[] { "s" }));
        Console.WriteLine(foo4.Invoke(null, new object[] { 1, "s" }));
    }
}

示例.cs：

public class Example
{
    public static void Foo<T>(int ID) { }
    public static void Foo<T, U>(int ID) { }
    public static void Foo<T>(string ID) { }
    public static string Foo<T, U>(int intID, string ID) { return ID; }
}

扩展.cs：

public static class Extensions
{
    public static MethodInfo GetGenericMethod(this Type t, string name, Type[] genericArgTypes, Type[] argTypes, Type returnType)
    {
        MethodInfo foo1 = (from m in t.GetMethods(BindingFlags.Public | BindingFlags.Static)
                           where m.Name == name &&
                           m.GetGenericArguments().Length == genericArgTypes.Length &&
                           m.GetParameters().Select(pi => pi.ParameterType).SequenceEqual(argTypes) &&
                           m.ReturnType == returnType
                           select m).Single().MakeGenericMethod(genericArgTypes);

        return foo1;
    }
}
于 2009-02-26T00:37:37.017 回答
1

更好的：

示例尝试获得正确的重载System.Linq.Enumerable.Select

    private static MethodInfo GetMethod<T>(Expression<Func<T>> expression)
    {
        return ((MethodCallExpression)expression.Body).Method;
    }

    public static void CallSelect()
    {
        MethodInfo definition = GetMethod(() => Enumerable.Select(null, (Func<object, object>)null)).GetGenericMethodDefinition();
        definition.MakeGenericMethod(typeof(int), typeof(int)).Invoke(null, new object[] { new List<int>(), ((Func<int, int>)(x => x)) });
    }
于 2012-02-06T17:36:59.293 回答
1

另一个找到MethodInfo你想要的方法是创建一个委托；

var methodInfo = new Action<int>(Example.Foo<object,object>).Method.GetGenericMethodDefinition();
于 2020-02-20T02:21:37.310 回答
0

这是您需要的 Linq 单线：

MethodInfo mi = exampleType.GetMethods().First(m=>m.GetGenericArguments().Length == 2);
于 2009-02-25T22:52:28.093 回答
0

我对您的 lambda 查询进行了一些修改。

当参数类型是泛型时，您必须这样做：

我加pi.ParameterType.GetGenericTypeDefinition()

和

(m.ReturnType.IsGenericType ? m.ReturnType.GetGenericTypeDefinition() : m.ReturnType) == returnType)

这样，该方法工作得很好

MethodInfo foo1 = (from m in t.GetMethods(BindingFlags.Public | BindingFlags.Static)
                         where m.Name == name
                         && m.GetGenericArguments().Length == genericArgTypes.Length
                         && m.GetParameters().Select(pi => pi.ParameterType.IsGenericType ? pi.ParameterType.GetGenericTypeDefinition() : pi.ParameterType).SequenceEqual(argTypes) &&
                         (returnType==null || (m.ReturnType.IsGenericType ? m.ReturnType.GetGenericTypeDefinition() : m.ReturnType) == returnType)
                         select m).FirstOrDefault();
      if (foo1 != null)
      {
        return foo1.MakeGenericMethod(genericArgTypes);
      }
      return null;

例子 ：

通过修改方法，我可以调用此扩展方法

public static IQueryable<T> FilterCulture<T>(this Table<T> t, IDatabaseFilter filter)

像这样使用我的新助手

var QueryableExpression = MethodInfoHelper.GetGenericMethod(typeof(LinqFilterExtension), "FilterCulture", new Type[] { rowType }, new Type[] { typeof(Table<>), typeof(IDatabaseFilter) }, typeof(IQueryable<>));

我的助手的签名是

   public static MethodInfo GetGenericMethod(Type t, string name, Type[] genericArgTypes, Type[] argTypes, Type returnType)
于 2009-04-22T18:25:17.813 回答