Question

以下是问题的一个示例：

   var source = new LambdasTestEntity[] { 
        new LambdasTestEntity {Id = 1},
        new LambdasTestEntity {Id = 2},          
        new LambdasTestEntity {Id = 3},
        new LambdasTestEntity {Id = 4},          
    };

    Expression<Func<LambdasTestEntity, bool>> expression1 = x => x.Id == 1;
    Expression<Func<LambdasTestEntity, bool>> expression2 = x => x.Id == 3;
    Expression<Func<LambdasTestEntity, bool>> expression3 = x => x.Id > 2;

    // try to chain them together in a following rule
    // Id == 1 || Id == 3 && Id > 2
    // as && has higher precedence, we expect getting two entities
    // with Id=1 and Id=3 

    // see how default LINQ works first
    Expression<Func<LambdasTestEntity, bool>> expressionFull = x => x.Id == 1 || x.Id == 3 && x.Id > 2;

    var filteredDefault = source.AsQueryable<LambdasTestEntity>()
              .Where(expressionFull).ToList();

    Assert.AreEqual(2, filteredDefault.Count); // <-this passes

    // now create a chain with predicate builder
    var totalLambda = expression1.Or(expression2).And(expression3);

    var filteredChained = source.AsQueryable<LambdasTestEntity>()
              .Where(totalLambda).ToList();


    Assert.AreEqual(2, filteredChained.Count);
    // <- this fails, because PredicateBuilder has regrouped the first expression,
    // so it now looks like this: (Id == 1 || Id == 3) && Id > 2

当我在Watches中查看两个表达式时，我会看到以下内容：

expressionFull as it is coming from Linq:
(x.Id == 1) OrElse ((x.Id == 3) AndAlso (x.Id > 2))

totalLambda for PredicateBuilder:
((x.Id == 1) OrElse Invoke(x => (x.Id == 3), x)) AndAlso Invoke(x => (x.Id > 2), x)

如果它与默认的Linq Expression构建器的行为不同，我发现使用PredicateBuilder有点不安全。

现在有些问题：

1）为什么Linq会创建这些组？即使我创建了Or表达式

x => x.Id == 1 || x.Id == 3 || x.Id > 2

我仍然得到这样分组的前两个标准：

((x.Id == 1) OrElse (x.Id == 3)) OrElse (x.Id > 2)

为什么不仅仅是

(x.Id == 1) OrElse (x.Id == 3) OrElse (x.Id > 2)

2）为什么PredicateBuilder会添加那些Invokes？我没有在默认的Linq表达式结果中看到Invokes，所以它们似乎没用......

3）有没有其他方法可以构建表达式“offline”然后传递给默认的Linq Expression构建器？像这样：

ex = x => x.Id == 1;
ex = ex || x.Id == 3;
ex = ex && x.Id > 2;

然后Linq Expression构建器然后解析它并创建与x =＆gt;相同的表达式x.Id == 1 || x.Id == 3＆amp;＆amp; x.Id＆gt; 2（给予＆amp;＆amp;更高的优先权）？或者也许我可以调整PredicateBuilder来做同样的事情？

Answer 1

扩展我的评论：

因为这里没有运算符优先级的概念。你是从字面上构建表达式树，并“管道” 一种方法的结果到下一个确定顺序。因此，顺序结果表达式将完全符合您的指定。

PredicateBuilder的完整来源已发布here，并显示它有多简单。但它也向您展示了上述问题的根源。如果您不想访问Albahari的网站，这里有完整的资料来源：

public static Expression<Func<T, bool>> Or<T> (this Expression<Func<T, bool>> expr1,
                                                 Expression<Func<T, bool>> expr2)
{
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ());
    return Expression.Lambda<Func<T, bool>>
         (Expression.OrElse (expr1.Body, invokedExpr), expr1.Parameters);
}

public static Expression<Func<T, bool>> And<T> (this Expression<Func<T, bool>> expr1,
                                                  Expression<Func<T, bool>> expr2)
{
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ());
    return Expression.Lambda<Func<T, bool>>
         (Expression.AndAlso (expr1.Body, invokedExpr), expr1.Parameters);
}

这里要注意的主要是它一次构建一个节点的表达式，然后将此节点作为后续节点的左表达式（叶子）进行管道。 Expression.Invoke调用只是将参数从现有节点传递到右侧叶子（下一个表达式），其余的是非常自我解释的。

编辑：我必须做类似的事情（但没有使用PredicateBuilder，使用Expression调用自己构建树）。要记住的主要事情是，您必须首先处理And/AndAlso节点，然后处理Or/OrElse节点，这样您就可以使用适当的优先级构建树。不幸的是，手工构建ExpressionTrees是一个循序渐进的过程，因此您必须确保将每个步骤分解为正确的顺序以获得您想要/需要的结果。

Linq PredicateBuilder，分组和运算符优先级

1 个答案: