Linq to SQL中如何动态构建多组(B_Id,State)条件的OR查询

这个动态构建OR条件的需求在Linq to SQL里太常见了，我来给你几个实用的解决方案，从简单到灵活的都有：

PredicateBuilder是LinqKit工具库专门用来构建动态And/Or表达式的利器，不用自己写复杂的表达式树。

首先你需要安装LinqKit包（根据你的ORM版本选择对应包，Linq to SQL用LinqKit，EF Core用LinqKit.Microsoft.EntityFrameworkCore）：

Install-Package LinqKit

然后按以下步骤实现：

1. 先定义一个条件组的模型（也可以直接用匿名类型，不过模型更清晰）：

public class BStateCondition
{
    public int B_Id { get; set; }
    public int State { get; set; }
}

2. 准备你的条件列表：

var conditions = new List<BStateCondition>
{
    new BStateCondition { B_Id = 101, State = 1001 },
    new BStateCondition { B_Id = 103, State = 1003 }
    // 可以添加任意多组条件
};

3. 用PredicateBuilder构建OR组合的条件：

// 初始化一个空的OR表达式（初始值为false，后续不断叠加OR）
var abPredicate = PredicateBuilder.New<AB>();
foreach (var cond in conditions)
{
    // 必须捕获当前循环变量，避免闭包引用同一变量的问题
    var currentCond = cond;
    abPredicate = abPredicate.Or(ab => ab.B_Id == currentCond.B_Id && ab.State == currentCond.State);
}

4. 把构建好的条件整合到最终查询里：

var query = dbContext.As
    .AsExpandable() // LinqKit需要这个方法来解析Invoke表达式，转换成原生SQL
    .Where(a => dbContext.ABs.Any(ab => ab.A_Id == a.Id && abPredicate.Invoke(ab)));

如果不想引入额外库，可以自己手动拼接表达式树，虽然麻烦一点但可控性强：

var conditions = new List<BStateCondition>
{
    new BStateCondition { B_Id = 101, State = 1001 },
    new BStateCondition { B_Id = 103, State = 1003 }
};

// 1. 构建AB表的OR条件表达式
var abParam = Expression.Parameter(typeof(AB), "ab");
Expression orExpression = Expression.Constant(false);

foreach (var cond in conditions)
{
    // 构建 ab.B_Id == cond.B_Id
    var bIdEqual = Expression.Equal(
        Expression.Property(abParam, nameof(AB.B_Id)),
        Expression.Constant(cond.B_Id));
    // 构建 ab.State == cond.State
    var stateEqual = Expression.Equal(
        Expression.Property(abParam, nameof(AB.State)),
        Expression.Constant(cond.State));
    // 把两个条件用AND组合
    var andExpr = Expression.AndAlso(bIdEqual, stateEqual);
    // 把当前AND条件和之前的OR表达式组合
    orExpression = Expression.OrElse(orExpression, andExpr);
}

// 2. 构建外层的查询条件：a => AB表中存在匹配A_Id且符合OR条件的记录
var aParam = Expression.Parameter(typeof(A), "a");
var aIdMatch = Expression.Equal(
    Expression.Property(abParam, nameof(AB.A_Id)),
    Expression.Property(aParam, nameof(A.Id)));
// 合并A_Id匹配和OR条件
var combinedCondition = Expression.AndAlso(aIdMatch, orExpression);
// 转换成Lambda表达式
var whereLambda = Expression.Lambda<Func<A, bool>>(combinedCondition, aParam);

// 3. 执行查询
var query = dbContext.As.Where(whereLambda);

如果你的Linq to SQL版本支持匿名类型的Contains，可以用这种极简写法：

var conditions = new List<BStateCondition>
{
    new BStateCondition { B_Id = 101, State = 1001 },
    new BStateCondition { B_Id = 103, State = 1003 }
};

// 把条件转换成匿名类型集合
var conditionTuples = conditions.Select(c => new { c.B_Id, c.State }).ToList();

// 直接用Contains实现多组OR的效果
var query = dbContext.As.Where(a => 
    dbContext.ABs.Any(ab => 
        ab.A_Id == a.Id && conditionTuples.Contains(new { ab.B_Id, ab.State })));

⚠️ 注意：部分旧版本Linq to SQL可能不支持匿名类型Contains，建议先测试是否能正确生成SQL。

• 闭包陷阱：循环构建表达式时，一定要捕获当前循环的变量（比如方案一里的currentCond = cond），否则所有表达式都会引用最后一个循环的变量值。
• 空条件处理：如果条件组为空，建议直接返回空集合，避免生成WHERE 1=0或者无过滤的SQL。
• 性能考量：如果条件组数量极多，要注意数据库的查询性能，不过Linq to SQL会自动把OR条件翻译成原生SQL的WHERE子句，大部分场景下没问题。

内容的提问来源于stack exchange，提问作者Mahdi Ataollahi