如何通过参数进行操作来编译方法callexpression

Question

我有一个方法方法

private static int Method(int n)
{
    return n;
}

我在我的表达式视图中的" vistmethodcall"中获得了MethodCallexPression。MethodCallexPression包含：

n => Method(2 + n)

我想将其编译为func并这样打电话：

func(3)

应该返回5。

我尝试了：

    IEnumerable<ParameterExpression> parameters = expression.Arguments.Select(a => Expression.Parameter(a.Type, a.ToString()));
    MethodCallExpression call = Expression.Call(expression.Method, parameters);
    Expression<Func<Int32, Int32>> lambda = Expression.Lambda<Func<int, int>>(call, call.Arguments.OfType<ParameterExpression>());
    var func = lambda.Compile();
    Console.WriteLine(func(3));

它是返回我3，而不是5

这是因为2 x是param名称，我用3。

Answer 1

不确定为什么要这样做，但是无论如何要这样做，您需要提取 MethodCallExpression使用的参数（不是参数）。为此，您可以这样滥用表达访问者：

public class ParametersExtractorVisitor : ExpressionVisitor {
    public IList<ParameterExpression> ExtractedParameters { get; } = new List<ParameterExpression>();
    protected override Expression VisitParameter(ParameterExpression node) {
        ExtractedParameters.Add(node);
        return base.VisitParameter(node);
    }
}

然后在您的代码中使用它：

var visitor = new ParametersExtractorVisitor();
visitor.Visit(expression);
MethodCallExpression call = Expression.Call(expression.Method, expression.Arguments);
Expression<Func<Int32, Int32>> lambda = Expression.Lambda<Func<int, int>>(call, visitor.ExtractedParameters);
var func = lambda.Compile();
Console.WriteLine(func(3));

Answer 2

您不需要访问者就可以实现它。
基本上，应在将值传递给lambda的情况下以2。

的恒定值的添加操作而提供您的Method函数。

using System;
using System.Linq.Expressions;
using System.Reflection;
namespace Test
{
    class Program
    {
        static void Main(string[] args) {
            var method = typeof(Program).GetMethod("Method", BindingFlags.Static | BindingFlags.Public);
            var parameter = Expression.Parameter(typeof(int), "n");
            var add = Expression.Add(Expression.Constant(2, typeof(int)), parameter);
            var methodCallExpression = Expression.Call(null, method, add);
            var lambda = Expression.Lambda<Func<int, int>>(methodCallExpression, parameter);
            var func = lambda.Compile();
            Console.WriteLine(func(3));
        }
        public static int Method(int n) => n;
    }
}

我将通过访客突变

来实现它

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace Test
{
    class MethodCallVisitor : ExpressionVisitor
    {
        private readonly int toAdd;
        public MethodCallVisitor(int toAdd) {
            this.toAdd = toAdd;
        }
        protected override Expression VisitMethodCall(MethodCallExpression node) {
            var add = Expression.Add(node.Arguments.First(), Expression.Constant(toAdd));
            return Expression.Call(node.Object, node.Method, add);
        }
    }
    class Program
    {
        static void Main(string[] args) {
            var methodCallVisitor = new MethodCallVisitor(2);
            var method = typeof(Program).GetMethod("Method", BindingFlags.Static | BindingFlags.Public);
            var parameter = Expression.Parameter(typeof(int), "n");
            var methodCallExpression = Expression.Call(null, method, parameter);
            var lambda = Expression.Lambda<Func<int, int>>(methodCallExpression, parameter);
            lambda = (Expression<Func<int, int>>)methodCallVisitor.Visit(lambda);
            var func = lambda.Compile();
            Console.WriteLine(func(3));
        }
        public static int Method(int n) => n;
    }
}