从另外两个表达式创建动态 lambda（链接表达式）

Question

给定一个接受识别对象并返回属性的 lambda：

Expression<Func<Identification, object>> fx = _ => _.Id;

以及将对象转换为识别实例的转换 lambda：

ParameterExpression p = Expression.Parameter(typeof(object), "o");
Expression @new = Expression.Lambda(Expression.Convert(p, typeof(Identification)), p);

如何构建一个执行 @new 的新 lambda（获取识别）实例）并将结果传递到fx。我需要 @new 的结果以某种方式绑定到 fx 的第一个参数，但我找不到示例。

我需要结果为 Expression，它的类型应为 Expression> 并且应将入站参数转换为 识别，然后获取Id属性。

Answer 1

首先，请注意，如果您正确键入 @new，这会更容易，即：

LambdaExpression @new = ...

因为这样可以轻松访问 @new.Body 和 @new.Parameters;做到了，
Expression.Invoke 在这里很有用：

var combinedParam = Expression.Parameter(typeof(object), "o");
var combined = Expression.Lambda<Func<object, object>>(
    Expression.Invoke(fx,
        Expression.Invoke(@new, combinedParam)), combinedParam);

尽管对于更清晰的表达式，您也可以使用 ExpressionVisitor 完全替换内部表达式：

var injected = new SwapVisitor(fx.Parameters[0], @new.Body).Visit(fx.Body);
var combined = Expression.Lambda<Func<object, object>>(injected,@new.Parameters);

with：

class SwapVisitor : ExpressionVisitor {
    private readonly Expression from, to;
    public SwapVisitor(Expression from, Expression to) {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node) {
        return node == from ? to : base.Visit(node);
    }
}

这样做的作用是：

• 检查 < code>fx.Body 树，用 @new.Body 替换 _ （参数）的所有实例（请注意，这将包含对 _ 的引用） code>o 参数（又名p）
• 然后，我们从替换的表达式构建一个新的 lambda，重新使用 @new 中的相同参数，这确保我们注入的值将被正确绑定

Answer 2

使用 Marc Gravell 的答案中的代码，您可以通过辅助函数很好地简化此操作：

public static class ExpressionHelper {
    public static Expression<Func<TFrom, TTo>> Chain<TFrom, TMiddle, TTo>(
        this Expression<Func<TFrom, TMiddle>> first,
        Expression<Func<TMiddle, TTo>> second
    ) {
        return Expression.Lambda<Func<TFrom, TTo>>(
           new SwapVisitor(second.Parameters[0], first.Body).Visit(second.Body),
           first.Parameters
        );
    }

    private class SwapVisitor : ExpressionVisitor {
        private readonly Expression _from;
        private readonly Expression _to;

        public SwapVisitor(Expression from, Expression to) {
            _from = from;
            _to = to;
        }

        public override Expression Visit(Expression node) {
            return node == _from ? _to : base.Visit(node);
        }
    }
}

现在看看它有多干净！

var valueSelector = new Expression<Func<MyTable, int>>(o => o.Value);
var intSelector = new Expression<Func<int, bool>>(x => x > 5);
var selector = valueSelector.Chain<MyTable, int, bool>(intSelector);

它可以与实体框架和其他需要干净的Expression的东西一起使用，而不会尝试调用其中的Func。