如何确定一个方法是否是泛型方法的泛型实例

Question

我有一个 MethodInfo 传递给一个函数，我想执行以下操作

MethodInfo containsMethod = typeof(ICollection<>).GetMethod("Contains");
if (methodInfo.Equals(containsMethod)
{
   // do something
}

但这不起作用，因为 methodInfo 具有特定的泛型类型。如果我知道 ICollection 始终是字符串类型，则该示例确实有效。

MethodInfo containsMethod = typeof(ICollection<string>).GetMethod("Contains");
if (methodInfo.Equals(containsMethod)
{
   // do something
}

如何检查 MethodInfo 是否是泛型方法的任何类型实例，而不关心类型是什么？

谢谢。

编辑：问题澄清

正如正确指出的那样，该方法不是通用的，但包含的类是通用的，所以问题更多的是如何找出 MethodInfo 是否适用于 ICollection<> 的类型实例。

编辑：更多上下文

我正在编写一个 Linq 提供程序并尝试处理“in”情况

IList<string> myList = new List<string>{ "1", "2" };

from Something s in ...
where myList.Contains(s.name)
select s;

Answer 1

请注意，ICollection.Contains 不是泛型方法 - 它是泛型类型的非泛型方法。否则，IsGenericMethod 和 GetGenericTypeDefinition 会有所帮助。您可以获取泛型类型定义 (DeclaringType.GetGenericTypeDefinition()) 并返回到 Contains，但我想知道您是否正在以困难的方式解决这个问题。

通常，如果您使用反射，则放弃到非通用 IList 可能是务实的 - 除非您需要类型数据（例如，用于元编程）。在这种情况下，我会考虑仔细查看是否可以简化此处的设置。

Answer 2

您可以检查声明类型：

if( methodInfo.Name == "Contains" 
    &&  methodInfo.DeclaringType.IsGenericType
    && methodInfo.DeclaringType.GetGenericTypeDefinition() == typeof(ICollection<>))
{

Answer 3

需要添加一些错误检查，但我相信这大致可以满足您的要求。您可以使用带或不带类型参数的方法作为参数。

static bool IsContainsMethod(MethodInfo methodInfo)
{
    Type[] types = { methodInfo.GetParameters().First().ParameterType };
    MethodInfo containsMethod = typeof(ICollection<>).MakeGenericType(types).GetMethod("Contains");
    return methodInfo.Equals(containsMethod);
}

Answer 4

问题是您没有泛型方法：您在泛型类型上有非泛型方法。我不知道如何使用反射直接从开放泛型类型上的方法定义转到封闭泛型类型上的相同方法，反之亦然。但是，您可以利用以下事实：开放泛型类型和封闭泛型类型上的 GetMethods() 返回的方法应始终采用相同的顺序，并按索引进行转换：

MethodInfo containsMethod = typeof(ICollection<>).GetMethod("Contains");
var methodIndex = Array.IndexOf(methodInfo.DeclaringType.GetMethods(), methodInfo);
var methodOnTypeDefinition = methodInfo.DeclaringType.GetGenericTypeDefinition().GetMethods()[methodIndex];
if (methodOnTypeDefinition.Equals(containsMethod))
{
    // do something
}

Answer 5

尝试这个方法

    public static bool CheckGenericMethod(MethodInfo methodInfo)
    {
        bool areSimilarMethods = false;
        MethodInfo methodToCompare = typeof(ISomeInterface<>).GetMethod("func");
        Type interfaceInfo = methodInfo.DeclaringType.GetInterface(methodToCompare.DeclaringType.FullName);

        if (interfaceInfo != null)
            areSimilarMethods = (methodToCompare.Name.Equals(methodInfo.Name)
            && interfaceInfo.FullName.Contains(methodToCompare.DeclaringType.FullName));
        else
        {
            areSimilarMethods = methodToCompare.DeclaringType.Equals(methodInfo.DeclaringType);
        }

        return areSimilarMethods;

    }

，这里是完整的示例用法。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace TestReflection
{
    public class Program
    {
        static void Main(string[] args)
        {
            MethodInfo info1 = typeof(ISomeInterface<>).GetMethod("func");
            MethodInfo info2 = typeof(MyStringCollection).GetMethod("func");
            MethodInfo info3 = typeof(MyProgramCollection).GetMethod("func");
            MethodInfo info4 = typeof(MyXCollection).GetMethod("func");

            if (CheckGenericMethod(info1)) Console.WriteLine("true");else Console.WriteLine("false");
            if (CheckGenericMethod(info2)) Console.WriteLine("true");else Console.WriteLine("false");
            if (CheckGenericMethod(info3)) Console.WriteLine("true");else Console.WriteLine("false");
            if (CheckGenericMethod(info4)) Console.WriteLine("true"); else Console.WriteLine("false");

            Console.ReadKey();
        }


        public static bool CheckGenericMethod(MethodInfo methodInfo)
        {
            bool areSimilarMethods = false;
            MethodInfo methodToCompare = typeof(ISomeInterface<>).GetMethod("func");
            Type interfaceInfo = methodInfo.DeclaringType.GetInterface(methodToCompare.DeclaringType.FullName);

            if (interfaceInfo != null)
                areSimilarMethods = (methodToCompare.Name.Equals(methodInfo.Name)
                && interfaceInfo.FullName.Contains(methodToCompare.DeclaringType.FullName));
            else
            {
                areSimilarMethods = methodToCompare.DeclaringType.Equals(methodInfo.DeclaringType);
            }

            return areSimilarMethods;

        }
    }

    public interface ISomeInterface<T> where T : class
    {
        T func(T s);
    }

    public class MyStringCollection : ISomeInterface<string>
    {
        public string func(string s)
        {
            return s;
        }
    }

    public class MyProgramCollection : ISomeInterface<Program>
    {
        public Program func(Program s)
        {
            return s;
        }
    }

    public class MyXCollection
    {
        public int func(int s)
        {
            return s;
        }
    }

}