在编译器生成的表达式树中使用表达式

Question

我知道我可以使用以下方法创建表达式树：

1. 工厂方法。

2. 编译器将 lambda 表达式转换为 Expression。

对于复杂的表达式树，我更喜欢 2，因为它更简洁。

这样可以引用已经构建好的Expressions吗？

using System;
using System.Linq.Expressions;

public class Test
{
    public static Expression<Func<int, int>> Add(Expression expr)
    {
#if false
        // works
        ParameterExpression i = Expression.Parameter(typeof(int));
        return Expression.Lambda<Func<int, int>>(Expression.Add(i, expr), i);
#else
        // compiler error, can I pass expr here somehow?
        return i => i + expr;
#endif
    }

    public static void Main()
    {
        Func<int, int> f = Add(Expression.Constant(42)).Compile();
        Console.WriteLine(f(1));
    }
}

Answer 1

没有任何开箱即用的功能，但您可以自己构建一个工具来提供此功能。

您可以编写一个接受具有两个参数的表达式的方法，一个“真实”参数和一个您想用另一个表达式的值替换的某个值的参数。然后，您可以拥有一个解析为该值的表达式，并将参数的所有实例替换为第二个表达式：

public static Expression<Func<TSource, TResult>> BuildExpression
    <TSource, TOther, TResult>(
    Expression<Func<TSource, TOther, TResult>> function,
    Expression<Func<TOther>> innerExpression)
{
    var body = function.Body.Replace(function.Parameters[1], innerExpression.Body);
    return Expression.Lambda<Func<TSource, TResult>>(body, function.Parameters[0]);
}

您可以使用以下方法将一个表达式的所有实例替换为另一个：

public static Expression Replace(this Expression expression,
    Expression searchEx, Expression replaceEx)
{
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
}
internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}

然后您可以将其应用于您的案例，如下所示：

public static Expression<Func<int, int>> Add(Expression<Func<int>> expr)
{
    return BuildExpression((int i, int n) => i + n, expr);
}

Answer 2

您不能将任意 Expression 实例与编译时表达式树混合。您可以做的是构造一个替换特定节点的新表达式树，因此您可以拥有i => i + marker，然后构造一个新树，其中marker 节点被您的运行时表达式替换。这需要写一个合适的ExpressionVisitor：

public static class ExpressionExtensions {
  public static T AsPlaceholder<T>(this Expression expression) {
    throw new InvalidOperationException(
      "Expression contains placeholders."
    );
  }

  public static Expression FillPlaceholders(this Expression expression) {
    return new PlaceholderExpressionVisitor().Visit(expression);
  }
}

class PlaceholderExpressionVisitor : ExpressionVisitor {
  protected override Expression VisitMethodCall(MethodCallExpression node) {
    if (
      node.Method.DeclaringType == typeof(ExpressionExtensions) && 
      node.Method.Name == "AsPlaceholder"  // in C# 6, we would use nameof()
    ) {
      return Expression.Lambda<Func<Expression>>(node.Arguments[0]).Compile()();
    } else {
      return base.VisitMethodCall(node);
    }
  }
}

Add 现在变成：

public static Expression<Func<int, int>> Add(Expression expr) {
    Expression<Func<int, int>> add = i => i + expr.AsPlaceholder<int>();
    return (Expression<Func<int, int>>) add.FillPlaceholders();
}

略显神秘的表达

Expression.Lambda<Func<Expression>>(node.Arguments[0]).Compile()()

可以通过观察编译器将捕获我们在闭包中插入的表达式来解释，无论它来自何处，因此方法调用的参数始终是对该闭包的引用，我们需要对其进行评估得到实际的表达。

这可以扩展到任意数量的替换表达式，并且显式键入最少。