如何在Entity Framework的LINQ查询中合理重构条件表达式

我有多个包含重复复杂条件集的LINQ查询，示例代码如下：

IEnumerable<MyEntity> MyRepoMt1()
{
  return _myContext.MyEntities.Where(<several rules A> && different stuff).ToList();
}

IEnumerable<MyEntity> MyRepoMt2()
{
  return _myContext.MyEntities.Where(<several rules A> && different stuff).ToList(); // 和上面方法用了相同的规则A
}
…
IEnumerable<MyEntity> MyRepoMt3()
{
  return _myContext.MyEntities.Where(<several rules B> && different stuff).ToList();
}

IEnumerable<MyEntity> MyRepoMt4()
{
  return _myContext.MyEntities.Where(<several rules B> && different stuff).ToList(); // 和上面方法用了相同的规则B
}

IEnumerable<MyEntity> MyRepoMt5()
{
  return _myContext.MyEntities.Where(<several rules A> || <several rules B>).ToList(); // 和之前方法用了相同的规则A和B
}

我想最优重构这些重复条件，最初尝试用返回bool的方法：

bool CheckRulesA(MyEntity e) { … }
bool CheckRulesB(MyEntity e) { … }

调用方式：

IEnumerable<MyEntity> MyRepoMt1()
{
  return _myContext.MyEntities.Where(e => CheckRulesA(e) && different stuff).ToList();
}

但这个方法失败了，因为EF没法在服务器端执行CheckRulesA，直接抛出了异常。

后来我改成处理IQueryable的方法：

IQueryable<MyEntity> CheckRulesA(IQueryable<MyEntity> query)
{
  return query.Where(e => …).ToList();
}

这解决了之前的问题，调用方式如下：

IEnumerable<MyEntity> MyRepoMt1()
{
  return CheckRulesA(_myContext.MyEntities).Where(different stuff…).ToList();
}

我可以把它改成扩展方法，但这不是重点。不过这种方式没法处理带||运算符的场景（比如MyRepoMt5），我需要返回满足规则A或规则B的实体，不想用var q2 = (CheckRulesA(_myContext.MyEntities).Concat(CheckRulesB(_myContext.MyEntities))).Distinct();这种不够优雅的实现，请问该怎么正确处理？

核心思路是用Expression<Func<MyEntity, bool>>封装独立的规则条件，这样既可以让EF解析成SQL，又能灵活组合&&、||逻辑。

1. 封装规则为表达式树 #

把重复的规则A、B定义为表达式树，而非普通方法或IQueryable处理方法：

// 封装规则A的具体逻辑
private static readonly Expression<Func<MyEntity, bool>> RulesA = e => 
    e.IsActive && e.CreatedDate >= DateTime.Now.AddMonths(-6);

// 封装规则B的具体逻辑
private static readonly Expression<Func<MyEntity, bool>> RulesB = e => 
    e.Priority == Priority.High && e.Status != Status.Resolved;

2. 实现表达式组合的扩展方法 #

要支持&&和||逻辑组合，需要编写两个扩展方法来合并表达式树：

public static class ExpressionExtensions
{
    // 合并两个表达式为 AndAlso（&&）逻辑
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        var parameter = Expression.Parameter(typeof(T));
        var visitor = new ReplaceParameterVisitor(left.Parameters[0], parameter);
        
        var leftBody = visitor.Visit(left.Body);
        var rightBody = visitor.Visit(right.Body);
        var combined = Expression.AndAlso(leftBody, rightBody);
        
        return Expression.Lambda<Func<T, bool>>(combined, parameter);
    }

    // 合并两个表达式为 OrElse（||）逻辑
    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
    {
        var parameter = Expression.Parameter(typeof(T));
        var visitor = new ReplaceParameterVisitor(left.Parameters[0], parameter);
        
        var leftBody = visitor.Visit(left.Body);
        var rightBody = visitor.Visit(right.Body);
        var combined = Expression.OrElse(leftBody, rightBody);
        
        return Expression.Lambda<Func<T, bool>>(combined, parameter);
    }

    // 辅助类：替换表达式中的参数，避免参数不匹配问题
    private class ReplaceParameterVisitor : ExpressionVisitor
    {
        private readonly ParameterExpression _oldParam;
        private readonly ParameterExpression _newParam;

        public ReplaceParameterVisitor(ParameterExpression oldParam, ParameterExpression newParam)
        {
            _oldParam = oldParam;
            _newParam = newParam;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            return node == _oldParam ? _newParam : base.VisitParameter(node);
        }
    }
}

3. 在仓储方法中灵活使用 #

现在可以适配所有业务场景，代码简洁且优雅：

场景1：规则A + 额外条件（MyRepoMt1、MyRepoMt2）

IEnumerable<MyEntity> MyRepoMt1()
{
    var condition = RulesA.And(e => e.Category == "Category1");
    return _myContext.MyEntities.Where(condition).ToList();
}

IEnumerable<MyEntity> MyRepoMt2()
{
    var condition = RulesA.And(e => e.OwnerId == currentUserId);
    return _myContext.MyEntities.Where(condition).ToList();
}

场景2：规则B + 额外条件（MyRepoMt3、MyRepoMt4）

IEnumerable<MyEntity> MyRepoMt3()
{
    var condition = RulesB.And(e => e.DueDate <= DateTime.Now);
    return _myContext.MyEntities.Where(condition).ToList();
}

IEnumerable<MyEntity> MyRepoMt4()
{
    var condition = RulesB.And(e => e.Tags.Contains("Urgent"));
    return _myContext.MyEntities.Where(condition).ToList();
}

场景3：规则A 或 规则B（MyRepoMt5）

IEnumerable<MyEntity> MyRepoMt5()
{
    var condition = RulesA.Or(RulesB);
    return _myContext.MyEntities.Where(condition).ToList();
}

方案优势 #

• 表达式树可被EF完整解析为SQL，避免客户端执行的异常；
• 规则逻辑仅定义一次，彻底消除重复代码；
• 支持自由组合&&、||逻辑，无论是单一规则加额外条件，还是多规则的或/与组合，都能优雅实现；
• 最终生成单一SQL查询，无需Concat+Distinct这类额外客户端处理，性能更优。

内容的提问来源于stack exchange，提问作者A.D.