如何在Lambda查询中使用OR运算符组合Where子句

当你多次调用Where方法时，LINQ会自动将条件以AND逻辑组合，这和你需要的OR逻辑不符。以下是几种实现动态OR条件的方案：

方案一：直接合并条件（适合简单场景） #

如果你的条件数量不多，可以直接在单个Where中处理所有动态判断，直接实现OR逻辑：

// 先判断是否有至少一个条件生效
bool hasAnyFilter = filtersMinDate != default || filtersMaxDate != default;

if (hasAnyFilter)
{
    query = query.Where(tv => 
        (filtersMinDate != default && tv.TimeStamp >= filtersMinDate) || 
        (filtersMaxDate != default && tv.TimeStamp <= filtersMaxDate));
}

方案二：用表达式树扩展实现动态OR组合（适合复杂场景） #

如果需要支持更多动态条件，可通过扩展表达式树来实现条件的OR拼接：

首先定义表达式扩展方法：

public static class ExpressionExtensions
{
    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 ParameterReplaceVisitor(left.Parameters[0], parameter);
        
        var leftBody = visitor.Visit(left.Body);
        var rightBody = visitor.Visit(right.Body);
        
        var orExpression = Expression.OrElse(leftBody, rightBody);
        return Expression.Lambda<Func<T, bool>>(orExpression, parameter);
    }

    private class ParameterReplaceVisitor : ExpressionVisitor
    {
        private readonly ParameterExpression _oldParam;
        private readonly ParameterExpression _newParam;

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

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

然后用这个扩展来动态构建查询：

var filterConditions = new List<Expression<Func<YourType, bool>>>();

if (filtersMinDate != default)
{
    filterConditions.Add(tv => tv.TimeStamp >= filtersMinDate);
}

if (filtersMaxDate != default)
{
    filterConditions.Add(tv => tv.TimeStamp <= filtersMaxDate);
}

if (filterConditions.Any())
{
    // 聚合所有条件为OR逻辑
    var combinedFilter = filterConditions.Aggregate((current, next) => current.Or(next));
    query = query.Where(combinedFilter);
}

方案三：使用第三方库（LinqKit PredicateBuilder） #

如果你不想自己写表达式扩展，可以直接使用LinqKit的PredicateBuilder，它封装了表达式树的组合逻辑：

var predicate = PredicateBuilder.New<YourType>(false);

if (filtersMinDate != default)
{
    predicate = predicate.Or(tv => tv.TimeStamp >= filtersMinDate);
}

if (filtersMaxDate != default)
{
    predicate = predicate.Or(tv => tv.TimeStamp <= filtersMaxDate);
}

query = query.Where(predicate);

注意：使用LinqKit时部分ORM需要调用AsExpandable()来确保表达式能正确解析。

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