c# - 从具有未知签名的 MethodInfo 创建表达式函数

Question

我希望仅从通过 Type.GetMethod() 检索到的 methodinfo 对象创建一个可缓存的 lambda 表达式，而无需对函数的类型转换进行编码。

除了从已编译表达式到类型化可调用函数的转换之外，我已经完成了所有工作。

var parameters = Array.ConvertAll(method.GetParameters(), input => Expression.Parameter(input.ParameterType));
var instanceExp = Expression.Constant(_implementation);
var call = Expression.Call(instanceExp, method, parameters);
var exp = Expression.Lambda(call, parameters).Compile();

缺少的是:

Func<T1,T2,T3> castExp =  (Func<T1,T2,T3>)exp;

我想做的是在不指定特定类型的情况下转换为具有特定数量参数的函数:

Func<object,object,object> castExp =  (Func<object,object,object>)exp;

这样我就可以调用 exp(o1, o2, o3) 而无需编写 o1 等的类型。但是将 Func 类型的函数转换为 Func 时出现运行时错误。

我如何将函数转换为允许传递未指定类型参数的某种形式的 func<,,>？

(顺便说一句:更改要调用的方法的签名不是一个选项。)

Answer 1

-1我已经部分解决了我遇到的问题。

如果方法不使用 in/out/ref 参数，我能够做的是为未知签名的方法创建表达式。在那种情况下，我不得不回退到 MethodInfo.Invoke 调用。

private object CallMethod(MethodInfo method, object obj, object[] parameters) {
    // Methods with void as return must be cast to Action instead of Function
    var voidMethod = voidMethod = method.ReturnType == typeof(void);
    // Methods with ref parameters can be called but the parameters won't work.
    var refMethod = Array.FindAll(method.GetParameters(), info => info.ParameterType.IsByRef;
    var paramExprs = getParamExpr(method);
    var paramTypes = getParamTypes(method, paramExprs);
    var instanceExp = Expression.Convert(paramExprs[0], method.DeclaringType);
    Expression call = null;
    if (voidMethod) {
        call = Expression.Call(instanceExp, method, paramTypes);
    } else {
        call = Expression.Convert(Expression.Call(instanceExp, method, paramTypes), typeof(object));
    }
    exp = Expression.Lambda(call, paramExprs).Compile();
    if (voidMethod) {
        switch (method.GetParameters().Length) {
        case 0:
            ((Action<object>)exp)(_obj);
            break;
        case 1:
            ((Action<object, object>)exp)(_obj, parameters[0]);
            break;
        // Continue here with more case statements.
        }
    } else {
        switch (method.GetParameters().Length) {
        case 0:
            result = ((Func<object, object>)exp)(_obj);
            break;
        case 1:
            result = ((Func<object, object, object>)exp)(_obj, parameters[0]);
            break;
        // Continue here with more case statements
        }
    }
    // Error handling omited
    return result;
}

private List<ParameterExpression> getParamExpr(MethodInfo method) {
    var list = new List<ParameterExpression>();
    list.Add(Expression.Parameter(typeof(object), "obj"));
    list.AddRange(Array.ConvertAll(method.GetParameters(), input => Expression.Parameter(typeof(object))));
    return list;
}

private List<Expression> getParamTypes(MethodInfo method, List<ParameterExpression> inList) {
    var list = new List<Expression>();
    var methParams = method.GetParameters();
    list.AddRange(
        // Skip the first item as this is the object on which the method is called.
        inList.Skip(1).Select(
            input => Expression.Convert(
                input,
                Type.GetType(
                        methParams[inList.IndexOf(input)-1].ParameterType.FullName.Replace("&", string.Empty)))));
    return list;
}

我希望它是完整的，因为我遗漏了很多用于错误处理等的样板文件。

表达式对象可以缓存，但每次调用它们时都必须进行转换。