C# 如何使用lambda表达式作为参数通过反射调用方法？

我想这样做：

MethodInfo m = myList.GetType().GetMethod("ConvertAll", System.Reflection.BindingFlags.InvokeMethod).MakeGenericMethod(typeof(object));
List<object> myConvertedList = (List<object>)m.Invoke(myList, new object[]{ (t => (object)t)});

MethodInfo m=myList.GetType（）.GetMethod（“ConvertAll”，System.Reflection.BindingFlags.InvokeMethod）.MakeGenericMethod（typeof（object））；
List myConvertedList=（List）m.Invoke（myList，新对象[]{（t=>（object）t）}）；

myList是特定类型（应用程序未知）的通用列表，我想将其转换为对象列表以执行某些操作

但是，此操作失败，出现以下错误：“无法将lambda表达式转换为“object”类型，因为它不是委托类型”

你能帮我找出哪里不对劲吗？我想做些不可能的事吗

还有其他方法可以实现同样的目的吗？

lambda形成一个方法组（基本上这是一个仅通过名称（和范围）标识的方法。由于可以重载具有相同名称的方法，因此一个方法组包含多个不同的成员）。这不能总是隐式转换为委托，因为委托实际上是从方法组中绑定到单个方法的。这在重载中起作用

不幸的是，这同样适用于你的情况。补救办法是明确授权：

List<object> myConvertedList = (List<object>)m.Invoke(myList, new object[]{ new Func<YourType, object>(t => (object)t)});

List myConvertedList=（List）m.Invoke（myList，new object[]{new Func（t=>（object）t）}）；

lambda表达式可以转换为委托类型或具有正确签名的表达式树，但您需要指定它是哪种委托类型

我认为，如果将此方法作为一种通用方法，您的代码会简单得多：

public static List<object> ConvertToListOfObjects<T>(List<T> list)
{
    return list.ConvertAll<object>(t => t);
}

公共静态列表转换器toListoFobjects（列表）
{
返回列表.ConvertAll（t=>t）；
}

然后，您只需要查找并一般调用该方法：

MethodInfo method = typeof(Foo).GetMethod("ConvertToListOfObjects",
    BindingFlags.Static | BindingFlags.Public);
Type listType = list.GetType().GetGenericArguments()[0];
MethodInfo concrete = method.MakeGenericMethod(new [] { listType });
List<object> objectList = (List<object>) concrete.Invoke(null, 
                                                   new object[]{list});

MethodInfo method=typeof（Foo）.GetMethod（“ConvertToListOfObjects”，
BindingFlags.Static | BindingFlags.Public）；
类型listType=list.GetType（）.GetGenericArguments（）[0]；
MethodInfo-concrete=method.MakeGenericMethod（新[]{listType}）；
List objectList=（List）concrete.Invoke（null，
新对象[]{list}）；

完整示例：

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

class Test
{
    public static List<object> ConvertToListOfObjects<T>(List<T> list)
    {
        return list.ConvertAll<object>(t => t);
    }

    static void Main()
    {
        object list = new List<int> { 1, 2, 3, 4 };

        MethodInfo method = typeof(Test).GetMethod("ConvertToListOfObjects",
            BindingFlags.Static | BindingFlags.Public);
        Type listType = list.GetType().GetGenericArguments()[0];
        MethodInfo concrete = method.MakeGenericMethod(new [] { listType });
        List<object> objectList = (List<object>) concrete.Invoke(null,
                                                    new object[] {list});

        foreach (object o in objectList)
        {
            Console.WriteLine(o);
        }
    }
}

使用系统；
运用系统反思；
使用System.Collections.Generic；
课堂测试
{
公共静态列表转换器ToListoFobjects（列表）
{
返回列表.ConvertAll（t=>t）；
}
静态void Main（）
{
对象列表=新列表{1,2,3,4}；
MethodInfo method=typeof（Test）.GetMethod（“ConvertToListOfObjects”，
BindingFlags.Static | BindingFlags.Public）；
类型listType=list.GetType（）.GetGenericArguments（）[0]；
MethodInfo-concrete=method.MakeGenericMethod（新[]{listType}）；
List objectList=（List）concrete.Invoke（null，
新对象[]{list}）；
foreach（objectList中的对象o）
{
控制台写入线（o）；
}
}
}

困难在于您的类型在这里的编译时不为人所知-因此我建议将其转换为泛型方法。啊，该死，我没有注意到这一点。是的，我正要评论同样的事情。。。无论如何谢谢你