Question

我一直在搜索有关当前问题的很多信息，但是找不到解决该问题的真正答案。

我正在尝试构建一个生成以下SQL的LINQ查询：

SELECT * FROM TABLE WHERE (Field1 = X, Field2 = Y ... ) or (Field3 = Z)

通常情况下，我会这样做：

Object.Where(c => (c.Field1 == X && c.Field2 == Y) || (c.Field3 == Z))

我无法使用这种方法，因为查询是通过使用多个.Where()调用来构建的。

举个例子：

// This is a short example, the real world situation has 20 fields to check and they are all connected with an AND.
if (model.Field1.HasValue) 
{
    Query = Query.Where(c => c.Field1 == X)
}

if (model.Field2.HasValue) 
{
    Query = Query.Where(c => c.Field2 == X)
}

[...] like 20 more of these .Where() calls.

那对我来说就是这么复杂。所有这些.Where()调用都在构建与AND连接的Linq查询，这很好。

如何让他们使用括号执行并现在使用API添加简单的OR？

有没有一种方法可以将谓词保存在某些变量中，这样我就可以进行以下操作：

Query = Query.Where(c => previousPredicates || c.Field3 == X)

或如何解决该问题？

我认为必须为这个特殊问题找到一个好的解决方案，我不是唯一需要它的人，但是我绝对不确定如何实现它。

P.S：我真的不能删除多个.Where()调用，并且直接写SQL都不是选择。

编辑 StackOverflow要我说为什么我的问题与其他问题不同。好吧，这是关于Parentheses的事情。我不想将所有.Where()与单个OR子句连接，我想将它们与AND留在一起，并在所有OR查询都加括号的同时添加另一个AND子句

Answer 1

如果要以编程方式构建查询并使其在SQL服务器上执行，而不是获取所有记录并在内存中进行查询，则需要在Expression类上使用一组静态方法来构建查询使用那些。在您的示例中：

public class Query // this will contain your 20 fields you want to check against
{
    public int? Field1; public int? Field2; public int? Field3; public int Field4;
}

public class QueriedObject // this is the object representing the database table you're querying
{
    public int QueriedField;
}

public class Program
{
    public static void Main()
    {
        var queryable = new List<QueriedObject>().AsQueryable();
        var query = new Query { Field2 = 1, Field3 = 4, Field4 = 2 };

        // this represents the argument to your lambda expression
        var parameter = Expression.Parameter(typeof(QueriedObject), "qo");

        // this is the "qo.QueriedField" part of the resulting expression - we'll use it several times later
        var memberAccess = Expression.Field(parameter, "QueriedField");

        // start with a 1 == 1 comparison for easier building - 
        // you can just add further &&s to it without checking if it's the first in the chain
        var expr = Expression.Equal(Expression.Constant(1), Expression.Constant(1));

        // doesn't trigger, so you still have 1 == 1
        if (query.Field1.HasValue)
        {
            expr = Expression.AndAlso(expr, Expression.Equal(memberAccess, Expression.Constant(query.Field1.Value)));
        }
        // 1 == 1 && qo.QueriedField == 1
        if (query.Field2.HasValue)
        {
            expr = Expression.AndAlso(expr, Expression.Equal(memberAccess, Expression.Constant(query.Field2.Value)));
        }
        // 1 == 1 && qo.QueriedField == 1 && qo.QueriedField == 4
        if (query.Field3.HasValue)
        {
            expr = Expression.AndAlso(expr, Expression.Equal(memberAccess, Expression.Constant(query.Field3.Value)));
        }

        // (1 == 1 && qo.QueriedField == 1 && qo.QueriedField == 4) || qo.QueriedField == 2
        expr = Expression.OrElse(expr, Expression.Equal(memberAccess, Expression.Constant(query.Field4)));

        // now, we combine the lambda body with the parameter to create a lambda expression, which can be cast to Expression<Func<X, bool>>
        var lambda = (Expression<Func<QueriedObject, bool>>) Expression.Lambda(expr, parameter);

        // you can now do this, and the Where will be translated to an SQL query just as if you've written the expression manually
        var result = queryable.Where(lambda);       
    }
}

Answer 2

首先，创建一些辅助程序扩展方法，以更轻松地组合两个Func<T,bool>谓词：

 public static Func<T, bool> And<T>(this Func<T, bool> left, Func<T, bool> right) 
     => a => left(a) && right(a);

 public static Func<T, bool> Or<T>(this Func<T, bool> left, Func<T, bool> right)
     => a => left(a) || right(a);

然后，您可以使用它们来链接谓词：

var list = Enumerable.Range(1, 100);

Func<int, bool> predicate = v => true; // start with true since we chain ANDs first

predicate = predicate.And(v => v % 2 == 0); // numbers dividable by 2
predicate = predicate.And(v => v % 3 == 0); // numbers dividable by 3
predicate = predicate.Or(v => v % 31 == 0); // numbers dividable by 31

var result = list.Where(predicate);

foreach (var i in result)
    Console.WriteLine(i);

输出：

Answer 3

好吧，您对linq有自己的答案。

让我介绍一种使用Dynamic.linq

的方法

// You could build a Where string that can be converted to linq.
// and do if sats and append your where sats string. as the example below
var query = "c => (c.Field1 == \" a \" && c.Field2 == Y) || (c.Field3 == \" b \")";
var indicator = query.Split('.').First(); // the indicator eg c
   // assume TABLE is the name of the class
var p = Expression.Parameter(typeof(TABLE), indicator);
var e = DynamicExpression.ParseLambda(new[] { p }, null, query);

// and simple execute the expression 
var items = Object.Where(e);

Answer 4

您可以使用Expression一步创建：

Expression<Func<Model, bool>> exp = (model => 
                                    ((model.Field1.HasValue && c.Field1 == X) &&
                                    (model.Field2.HasValue && c.Field2 == X)) ||
                                     model.Field3 == X
                                    )

一旦定义了谓词，在查询中使用它们就非常容易。

var result = Query.AsQueryable().Where(exp)

检查以下要点中的代码： my gist url

更新1： 如果必须使用步骤来创建表达式，则可以使用以下方法：

Expression<Func<Model, bool>> exp = c => true;
if (model.Field1.HasValue) 
{
    var prefix = exp.Compile();
    exp = c => prefix(c) && c.Field1 == X;
}

if (model.Field2.HasValue) 
{
    var prefix = exp.Compile();
    exp = c => prefix(c) && c.Field2 == X;
}

[...] like 20 more of these .Where() calls.

C＃Linq：将多个.Where（）与* OR *子句组合

4 个答案: