如何在Lambda表达式中排除空值？及Specification模式过滤实现咨询

嘿，你用Specification模式来替代繁琐的if-else过滤，这个思路非常棒！我来帮你把这块代码补全，同时详细说说怎么在Lambda表达式里优雅地排除空值或空字符串的情况。

首先，每个Specification类需要封装单个过滤逻辑，并且自动忽略空值/空字符串的过滤条件。假设你的Specification基类是标准的模式实现：

public abstract class Specification<T>
{
    public abstract Expression<Func<T, bool>> ToExpression();

    public Specification<T> And(Specification<T> other)
    {
        return new AndSpecification<T>(this, other);
    }

    // 可按需添加Or、Not等组合方法
}

public class AndSpecification<T> : Specification<T>
{
    private readonly Specification<T> _left;
    private readonly Specification<T> _right;

    public AndSpecification(Specification<T> left, Specification<T> right)
    {
        _left = left;
        _right = right;
    }

    public override Expression<Func<T, bool>> ToExpression()
    {
        var leftExpr = _left.ToExpression();
        var rightExpr = _right.ToExpression();

        var paramExpr = Expression.Parameter(typeof(T));
        var combinedExpr = Expression.AndAlso(
            Expression.Invoke(leftExpr, paramExpr),
            Expression.Invoke(rightExpr, paramExpr)
        );

        return Expression.Lambda<Func<T, bool>>(combinedExpr, paramExpr);
    }
}

接下来，针对CustomerModel的每个字段实现具体的Specification，在ToExpression方法里判断过滤值是否为空，为空则返回true（即不应用该过滤条件）：

1. CustomerNameSpecification #

public class CustomerNameSpecification : Specification<CustomerModel>
{
    private readonly CustomerModel _filter;

    public CustomerNameSpecification(CustomerModel filter)
    {
        _filter = filter;
    }

    public override Expression<Func<CustomerModel, bool>> ToExpression()
    {
        // 如果Name是空/空字符串/空白，就跳过这个过滤条件
        if (string.IsNullOrWhiteSpace(_filter.Name))
            return customer => true;

        // 可按需改成Equals、StartsWith等匹配逻辑
        return customer => customer.Name.Contains(_filter.Name);
    }
}

2. CustomerNoSpecification #

public class CustomerNoSpecification : Specification<CustomerModel>
{
    private readonly CustomerModel _filter;

    public CustomerNoSpecification(CustomerModel filter)
    {
        _filter = filter;
    }

    public override Expression<Func<CustomerModel, bool>> ToExpression()
    {
        if (string.IsNullOrWhiteSpace(_filter.CustomerNo))
            return customer => true;

        // 客户编号一般用精确匹配
        return customer => customer.CustomerNo == _filter.CustomerNo;
    }
}

3. 补全你的GetAllAsync方法 #

现在你可以把多个Specification组合起来，最终的查询逻辑会自动忽略空值条件：

public async Task<List<CustomerModel>> GetAllAsync(CustomerModel customer, Order order = Order.Ascending, int pageIndex = 1, int pageSize = int.MaxValue) 
{ 
    var skip = (pageIndex - 1) * pageSize; 
    var filter = new CustomerNameSpecification(customer) 
        .And(new CustomerNoSpecification(customer))
        // 可继续添加其他Specification，比如邮箱、年龄过滤等
        .And(new CustomerEmailSpecification(customer));

    // 构建查询
    var query = _dbContext.Customers.Where(filter.ToExpression());

    // 处理排序（这里假设按创建时间排序，可替换为你的业务字段）
    query = order == Order.Ascending 
        ? query.OrderBy(c => c.CreatedAt) 
        : query.OrderByDescending(c => c.CreatedAt);

    // 分页并返回结果
    return await query.Skip(skip).Take(pageSize).ToListAsync();
}

如果你不需要用Specification模式，直接在Lambda里处理的话，核心逻辑是：当过滤值为空时，该条件自动为true（即不过滤），否则执行匹配逻辑。比如：

var query = _dbContext.Customers
    .Where(c => 
        // 字符串类型：空值/空字符串/空白都跳过过滤
        (string.IsNullOrWhiteSpace(customer.Name) || c.Name.Contains(customer.Name)) &&
        (string.IsNullOrWhiteSpace(customer.CustomerNo) || c.CustomerNo == customer.CustomerNo) &&
        // Nullable值类型：比如Age是int?，空值则跳过
        (customer.Age == null || c.Age == customer.Age) &&
        // 枚举类型：默认值则跳过
        (customer.Status == default || c.Status == customer.Status)
    );

这种写法虽然直接，但字段多了之后会变得冗长，这也是Specification模式更适合复杂过滤场景的原因——每个过滤逻辑封装成单独的类，可读性和可维护性更高。

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