将 lambda 作为参数分配给通过反射调用的泛型方法

Question

考虑如下通用方法：

class SomeClass
{
    public static void SomeMethod<T>(Func<T>);
}

我想使用反射来调用这个方法。这是我能做到的：

_SomeMethod = typeof(SomeClass).GetMethod("SomeMethod",
    BindingFlags.Public | BindingFlags.Static);
Type type = typeof(SomeType); //Actually SomeType is extracted using reflection and it's not fixed
MethodInfo toBeCalled = _SomeMethod.MakeGenericMethod(type);
object obj = Activator.CreateInstance(type);
toBeCalled.Invoke(null, () => obj);

但它给出了编译错误：

Error CS1660: Cannot convert `lambda expression' to non-delegate type `object' (CS1660)

这是绝对可以接受的，但有什么解决方法？

请记住，使用 lambda 创建的 closure 是我需要的，所以不要删除它。

[更新]

澄清情况以使其有意义；使用 lambda 创建的仿函数是 SomeMethod 用于创建类 SomeType 的实例的实例化器。但我不想在仿函数中实际创建对象，而是从之前的实例化对象集合中返回它。最简单的方法是将 obj 放在 lambda 返回的闭包中，你不觉得吗？

Answer 1

我认为您希望通过采用Func<T> 并且“func”始终是身份的已知对象或通用方法。再添加一个包装器可能会有所帮助：

public void SomeMethodInvokerRuntime(Type typeofSomeClass, object obj)
{
    var _SomeMethod = this.GetType().GetMethod("SomeMethodInvoker", 
        BindingFlags.Public | BindingFlags.Static);
    MethodInfo toBeCalled = _SomeMethod.MakeGenericMethod(obj.GetType());
    toBeCalled.Invoke(null, new[]{typeofSomeClass, obj});
}

public static void SomeMethodInvoker<T>(Type typeofSomeClass, T obj)
{
    var _SomeMethod = typeofSomeClass.GetMethod("SomeMethod",
          BindingFlags.Public | BindingFlags.Static);
    MethodInfo toBeCalled = _SomeMethod.MakeGenericMethod(typeof(T));
    Func<T> that = () => obj; // Main part - strongly typed delegate
    toBeCalled.Invoke(null, new[]{that});
}

示例用法：

static class Test
{
    public static void SomeMethod<T>(Func<T> f)
    {
        Console.WriteLine((T)(f()));
    }
}

SomeMethodInvoker(typeof(Test), 3);
object obj = "test";

SomeMethodInvokerRuntime(typeof(Test), obj);

或者，您可以构建表达式并编译成函数，如Jon Skeet's answer 所示。

Answer 2

这听起来不像你真的需要一个 lambda 表达式。您可以使用表达式树构建一个函数以非常轻松地返回一个常量值：

var expression = Expression.Constant(obj, type);
var delegateType = typeof(Func<>).MakeGenericType(type);
var func = Expression.Lambda(delegateType, expression).Compile();
toBeCalled.Invoke(null, func);

Answer 3

简化为最简单的形式，我们有这样的：

void Main()
{
    MethodInfoInvoke(()=> {} );
}

void MethodInfoInvoke(object func)
{
}

失败并出现同样的错误。

现在，如果我们在委托中传递 lambda，看起来会更快乐：

void Main()
{
    Object obj = new Object();
    Func<object> action = ()=> obj; ;
    MethodInfoInvoke(action);      // accepted!
}