扩展访问表达式以检查值

我目前正在尝试与表达式树进行斗争，以实现一些神奇的效果，但我不断遇到一个又一个的错误。

我的一些域对象（实体框架）上有一些类似的属性

Expression<Func<DomainObject, LinkedDomainObject>> IncludeExpr
{
   get {
      return o => o.SomeLinkedObject;
   }
}

另一个表达式检查链接对象在某些属性（例如 ID）上的相等性。

我确实有一个表达式，它还检查链接对象是否为空，这样我就可以编写一个NotNull and Matched ID表达式通过反转空检查表达式并将其组合AndAlso与 ID 检查表达式。

我想采取o => o.SomeLinkedObject表达和linkedObject => linkedObject.ID == idVar表达式并将它们混合在一起以有效地获得：

o => o.LinkedObject != null && o.LinkedObject.Id == idVar

但我一生都无法弄清楚如何根据这两个单独的表达式将表达式树组合在一起。

我们可以花点时间创建一个辅助方法，可以使解决这个问题变得非常简单。如果我们创建一个方法，让我们可以像编写委托一样轻松地编写表达式，那么这将变得非常容易。我们的Compose方法将接受一个表达式，另一个接受第一个表达式的输出并将其转换为其他内容，创建一个新表达式，该表达式可以将第一个输入类型的某些内容转换为第二个输出的输出：

public static Expression<Func<TFirstParam, TResult>>
    Compose<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first,
    Expression<Func<TIntermediate, TResult>> second)
{
    var param = Expression.Parameter(typeof(TFirstParam), "param");

    var newFirst = first.Body.Replace(first.Parameters[0], param);
    var newSecond = second.Body.Replace(second.Parameters[0], newFirst);

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param);
}

这取决于以下方法将一个表达式的所有实例替换为另一个表达式：

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);
    }
}

现在我们可以创建一个IsNotNull转变非常容易：

public static Expression<Func<TSource, bool>> IsNotNull<TSource, TKey>(
    this Expression<Func<TSource, TKey>> expression)
{
    return expression.Compose(key => key != null);
}

As for And- 将两个表达式放在一起，如果使用 LINQ 查询提供程序，最简单的选择就是调用Where分别对每个表达式进行处理（如果可以的话）。如果没有，您可以使用PrediacteBuilder to And or Or两个表达式连在一起：

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> True<T>() { return f => true; }
    public static Expression<Func<T, bool>> False<T>() { return f => false; }

    public static Expression<Func<T, bool>> Or<T>(
        this Expression<Func<T, bool>> expr1,
        Expression<Func<T, bool>> expr2)
    {
        var secondBody = expr2.Body.Replace(
            expr2.Parameters[0], expr1.Parameters[0]);
        return Expression.Lambda<Func<T, bool>>
              (Expression.OrElse(expr1.Body, secondBody), expr1.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(
        this Expression<Func<T, bool>> expr1,
        Expression<Func<T, bool>> expr2)
    {
        var secondBody = expr2.Body.Replace(
            expr2.Parameters[0], expr1.Parameters[0]);
        return Expression.Lambda<Func<T, bool>>
              (Expression.AndAlso(expr1.Body, secondBody), expr1.Parameters);
    }
}