C#：按类型获取方法（通用列表）

Question

我有一个类很少有泛型重载方法。我正在尝试通过其参数类型来获取特定的参数。当我坚持前两个（使用 int 和 string 类型的参数）时，它相对容易做到。但是无论我做什么，我都无法让我的程序注意到第三个，用于通用列表。我使用了错误的类型参数吗？如果是这样，什么是正确的方法？

/* rest of code */
    static void Main(string[] args) {
        MethodInfo method =
            typeof(c).GetMethod("m", new Type[] { typeof(int) });

        Console.WriteLine(method);

        method =
            typeof(c).GetMethod("m", new Type[] { typeof(String) });

        Console.WriteLine(method);

        method =
            typeof(c).GetMethod("m", new Type[] { typeof(IEnumerable<>) });

        Console.WriteLine(method);

        Console.ReadKey();
    }
}

static class c
{
    public static void m<T>(int i)
    {
    }

    public static void m<T>(String s)
    {
    }

    public static void m<T>(IEnumerable<T> Ls)
    {
    }
}

Answer 1

短版：typeof(IEnumerable<>) 与typeof(IEnumerable<T>) 不同（对于某些T）。

更长的版本：没有方法void c.m(IEnumerable<> Ls)，只有在泛型参数将是某些特定的情况下重载-存在于运行时-由于某些代码引用泛型的实例化而需要抖动来创建方法的类型方法。

在您的测试代码中添加对通用方法的某个实例的调用，然后为该实例执行GetMethod。

考虑以下几点：

using System.Collections.Generic;
using System.Linq;
using static System.Console;

class Methods {
    public static void M(int x)     {
        // no-op
    }

    public static void M<T>(IEnumerable<T> x)     {
        // no-op
    }
}

class Program {
    static void Main(string[] args)  {
        Methods.M(0);
        Methods.M(new[] { "a", "b" });

        ShowAllM();
    }

    public static void ShowAllM() {
        var tm = typeof(Methods);
        foreach (var mi in tm.GetMethods().Where(m => m.Name == "M"))
        {
            WriteLine(mi.Name);
            foreach (var p in mi.GetParameters())
            {
                WriteLine($"\t{p.ParameterType.Name}");
            }
        }
    }
}

产生输出：

米 整数32 米 IEnumerable`1

请注意，泛型重载只有一个结果。如果对M<char>(…) 的调用添加到Main，则输出相同。

对于反射只有一种方法，它的参数是否反映了它的“开放泛型”性质，但这与可以使用开放泛型类型（例如IEnumerable<>）调用的方法不同，因为开放类型不是可实例化。

（我在这里捏造了很多技术细节。看看调试器中typeof(IEnumerable<>) 和typeof(IEnumerable<int>) 之间的区别很有启发性。）

Answer 2

第三种方法的签名为 m<T>(IEnumerable<T>)，但您的示例显示了尝试查找签名为 m(IEnumerable<>) 的方法。

typeof(IEnumerable<T>) 和typeof(IEnumerable<>) 的区别在于前者是泛型类型，后者是泛型类型定义，它们不是一回事。泛型类型由泛型类型定义和泛型类型参数确定。

考虑到这一点，您会想要使用：

method =
        typeof(c).GetMethod("m", new Type[] { typeof(IEnumerable<MyType>) });

并替换您将传递给方法的可枚举类型。

另一方面，如果您事先不知道可枚举的类型，您可以获取泛型方法定义并在需要时创建可用的泛型方法：

methodDef =
        typeof(c).GetMethod("m", new Type[] { typeof(IEnumerable<object>) }).GetGenericMethodDefinition();
method = methodDef.MakeGenericMethod(new Type[] { typeof(MyType) });

Answer 3

如果您从 int 和 string 方法中删除通用定义：

    public static void m(int i)
    {
    }

    public static void m(String s)
    {
    }

    public static void m<T>(IEnumerable<T> Ls)
    {
    }

并使用以下几行来获取所需的通用方法：

method = typeof(c).GetMethods().FirstOrDefault(m => m.IsGenericMethod &&
                    m.GetParameters()[0].ParameterType.GetGenericTypeDefinition()
                        == typeof(IEnumerable<>));

这样就可以了

Answer 4

/// <summary>
/// Will fetch first occurence of IEnumerable<T> method and generate new generic method 
/// <para/>
/// that corresponds to Document type
/// </summary>
/// <param name="Document"></param>
/// <param name="MethodName"></param>
/// <returns></returns>
public static MethodInfo GetAppropriateCollectionGenericMethod(object SourceClass, dynamic Document, string MethodName)
{

    //get all public methods
    var publicMethods = SourceClass.GetType().GetMethods().Where(x => x.Name == MethodName && x.IsGenericMethod);

    //filter out only useful methods
    foreach (var goodMethod in publicMethods)
    {
        var methodParams = goodMethod.GetParameters();
        var firstParameterType = methodParams[0].ParameterType;
        //methods that has arguments like Ienumerable<T>, RepeatedField<T> and so on
        var hasNested = firstParameterType.GenericTypeArguments.Length > 0;
        if (hasNested == true)
        {
            //if we found first method with that name that has as parameter an IEnumerable<T> we are ok
            var genericTypeDef = firstParameterType.GetGenericTypeDefinition();
            if (genericTypeDef == typeof(IEnumerable<>))
            {
                //Recover current document type, even if it's a list of such types
                Type documentType = GetDocumentNestedType(Document);
                //simply create a generic method based on Document inner Type
                return goodMethod.MakeGenericMethod(documentType);
            }
        }
    }

    return null;

}

您将需要这个，以避免错误：

var hasNested = firstParameterType.GenericTypeArguments.Length > 0;

这将获取第一次出现的：

public static void m<T>(IEnumerable<T> Ls)
{
}

并将生成一个您可以使用的方法：

var localMethod = GenericReflectionHelper.GetAppropriateCollectionGenericMethod(this, Document, nameof(Insert));

//we are relying on implicit casting

localMethod.Invoke(this, new object[] { Document });

完整样本：

public void Insert<T>(T Document)
        {
            //Valid for Lists and Repeated Fields
            if (Document is IEnumerable)
            {

                MethodInfo localMethod;
                var tuple = Tuple.Create(Document.GetType(), nameof(Insert));
                if (CachedMethodsRedirection.ContainsKey(tuple) == true)
                {
                    localMethod = CachedMethodsRedirection[tuple];
                }
                else
                {
                    localMethod = GenericReflectionHelper.GetAppropriateCollectionGenericMethod(this, Document, nameof(Insert));
                    CachedMethodsRedirection.Add(tuple, localMethod);
                }

                //we are relying on implicit casting
                localMethod.Invoke(this, new object[] { Document });

            }
            else
            {

                DocumentSession.GetCollection<T>().Insert(Document);

            }
        }

public void Insert<T>(IEnumerable<T> Document)
        {
            DocumentSession.GetCollection<T>().Insert(Document);
        }