如何重构LINQ谓词为Func变量并动态拼接查询条件？

方法一：用Func<Buyer, bool>拼接条件（适合内存集合/接受Func的Repository） #

先定义基础匹配条件，再根据model.Id的值动态追加额外判断：

// 基础条件：匹配身份证号
Func<Buyer, bool> baseCondition = x => x.IdentificationNumber == model.IdentificationNumber;

if (model.Id > 0)
{
    // 追加排除当前ID的条件
    var combinedCondition = x => baseCondition(x) && model.Id != x.Id;
    return _buyerRepository.Exists(combinedCondition);
}

return _buyerRepository.Exists(baseCondition);

嫌重复代码麻烦的话，可以加个通用扩展方法简化组合逻辑：

public static Func<T, bool> And<T>(this Func<T, bool> first, Func<T, bool> second)
{
    return x => first(x) && second(x);
}

之后就能这样用：

if (model.Id > 0)
{
    baseCondition = baseCondition.And(x => model.Id != x.Id);
}

方法二：用表达式树拼接条件（适合EF Core等ORM场景） #

如果你的Repository基于IQueryable（比如EF Core），直接传Func会导致客户端评估（把全表数据拉到内存再筛选），这时候必须用表达式树让ORM把条件转成SQL。

手动拼接版本 #

// 定义参数x（对应LINQ里的x => ...）
var param = Expression.Parameter(typeof(Buyer), "x");

// 基础条件：x.IdentificationNumber == model.IdentificationNumber
var baseExpr = Expression.Equal(
    Expression.Property(param, nameof(Buyer.IdentificationNumber)),
    Expression.Constant(model.IdentificationNumber)
);

if (model.Id > 0)
{
    // 额外条件：model.Id != x.Id
    var excludeSelfExpr = Expression.NotEqual(
        Expression.Constant(model.Id),
        Expression.Property(param, nameof(Buyer.Id))
    );
    // 组合成：基础条件 && 额外条件
    baseExpr = Expression.AndAlso(baseExpr, excludeSelfExpr);
}

// 构建最终的表达式树
var finalCondition = Expression.Lambda<Func<Buyer, bool>>(baseExpr, param);

return _buyerRepository.Exists(finalCondition);

通用扩展方法版本（更简洁） #

先写一个表达式树的组合扩展：

public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
    var param = Expression.Parameter(typeof(T));
    var visitor = new ParameterReplacer(second.Parameters[0], param);
    
    var left = first.Body;
    var right = visitor.Visit(second.Body);
    
    return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(left, right), param);
}

// 用于替换表达式树中的参数，避免参数不匹配问题
private class ParameterReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _oldParam;
    private readonly ParameterExpression _newParam;

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

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

然后业务代码就可以简化成：

Expression<Func<Buyer, bool>> baseCondition = x => x.IdentificationNumber == model.IdentificationNumber;

if (model.Id > 0)
{
    baseCondition = baseCondition.AndAlso(x => model.Id != x.Id);
}

return _buyerRepository.Exists(baseCondition);

怎么选？ #

• 要是操作内存集合或者Repository接受Func参数，用方法一足够简单。
• 要是用EF Core等ORM，必须用方法二，保证条件能转成SQL，避免性能问题。

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