如何封装可在Linq-to-Entities中复用的自定义过滤函数？

我有大量需过滤的表格数据，支持按列过滤，涉及int、double、string、bool、date等多种数据类型，过滤条件由前端指定。以int类型为例，过滤规则是：当指定最小值时，仅保留不小于该值的数据。

用Linq + Entity Framework 6直接写过滤逻辑很简单：

IQueryable<Data> data = db.Data;

data = data.Where(item => (filter.MinValue == null || filter.MinValue <= item.a))

但这类代码要重复写数百次，复杂场景下维护成本极高。

我尝试把相同逻辑封装成函数：

public bool Min(int? minValue, int value)
{
    return minValue == null || value >= minValue;
}

在Linq-to-Objects场景下调用没问题：

List<Data> data = db.Data.ToList();
data = data.Where(item => Min(filter.MinValue, item.a))

但放到Linq-to-Entities场景就会报错：

IQueryable<Data> data = db.Data;
data = data.Where(item => Min(filter.MinValue, item.a))

报错信息：

System.NotSupportedException: LINQ to Entities does not recognize the method 'Boolean Min(System.Nullable`1[System.Int32], System.Int32)' method, and this method cannot be translated into a store expression.

这是Linq-to-Entities的特性，现在需要解决的是：能否把过滤逻辑封装成可在Linq-to-Entities中重复使用的类函数，避免重复编写相似代码？ 要求必须用Linq-to-Entities（内存过滤性能不足），且方法要能适配任意含待过滤字段的对象，不能局限于特定实体类型。

解决方案 #

方法1：用表达式树构建通用过滤谓词 #

核心是通过表达式树动态生成EF可解析的过滤逻辑，既能复用规则，又能被转换成SQL执行。

先定义通用过滤工具类，针对每种数据类型编写表达式生成方法：

public static class FilterExpressions
{
    // Int类型最小值过滤
    public static Expression<Func<T, bool>> IntMinFilter<T>(Expression<Func<T, int>> propertySelector, int? minValue)
    {
        if (!minValue.HasValue)
            return _ => true;

        var parameter = propertySelector.Parameters[0];
        var propertyAccess = propertySelector.Body;
        var minValueConstant = Expression.Constant(minValue.Value);
        var greaterThanOrEqual = Expression.GreaterThanOrEqual(propertyAccess, minValueConstant);

        return Expression.Lambda<Func<T, bool>>(greaterThanOrEqual, parameter);
    }

    // 扩展string类型模糊过滤
    public static Expression<Func<T, bool>> StringContainsFilter<T>(Expression<Func<T, string>> propertySelector, string keyword)
    {
        if (string.IsNullOrEmpty(keyword))
            return _ => true;

        var parameter = propertySelector.Parameters[0];
        var propertyAccess = propertySelector.Body;
        var keywordConstant = Expression.Constant(keyword);
        var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });
        var containsCall = Expression.Call(propertyAccess, containsMethod, keywordConstant);

        return Expression.Lambda<Func<T, bool>>(containsCall, parameter);
    }

    // 同理可扩展double、date、bool等类型的过滤方法
}

使用方式：

IQueryable<Data> data = db.Data;
// 对Data实体的a字段应用int最小值过滤
data = data.Where(FilterExpressions.IntMinFilter<Data>(d => d.a, filter.MinValue));

// 对其他实体的字段复用逻辑
IQueryable<Order> orders = db.Orders;
orders = orders.Where(FilterExpressions.IntMinFilter<Order>(o => o.TotalAmount, orderFilter.MinAmount));

方法2：封装为IQueryable扩展方法（简化调用） #

把表达式树逻辑包装成扩展方法，让代码更简洁：

public static class QueryableFilterExtensions
{
    public static IQueryable<T> WhereIntMin<T>(this IQueryable<T> query, Expression<Func<T, int>> propertySelector, int? minValue)
    {
        if (!minValue.HasValue)
            return query;

        var filterExpr = FilterExpressions.IntMinFilter(propertySelector, minValue);
        return query.Where(filterExpr);
    }

    public static IQueryable<T> WhereStringContains<T>(this IQueryable<T> query, Expression<Func<T, string>> propertySelector, string keyword)
    {
        if (string.IsNullOrEmpty(keyword))
            return query;

        var filterExpr = FilterExpressions.StringContainsFilter(propertySelector, keyword);
        return query.Where(filterExpr);
    }
}

调用方式更直观：

IQueryable<Data> data = db.Data
    .WhereIntMin(d => d.a, filter.MinValue)
    .WhereStringContains(d => d.Name, filter.NameKeyword);

方法3：通用过滤条件类+表达式生成器（适配动态多条件） #

如果需要支持前端动态传递的复杂过滤组合，可以定义通用条件类和生成器：

// 通用过滤条件类
public class FilterCondition<T>
{
    public Expression<Func<T, object>> PropertySelector { get; set; }
    public FilterOperator Operator { get; set; }
    public object Value { get; set; }
}

public enum FilterOperator
{
    GreaterThanOrEqual,
    LessThanOrEqual,
    Contains,
    Equal
    // 可扩展其他操作符
}

// 表达式生成器
public static class FilterBuilder
{
    public static Expression<Func<T, bool>> BuildFilter<T>(FilterCondition<T> condition)
    {
        var parameter = condition.PropertySelector.Parameters[0];
        var propertyAccess = condition.PropertySelector.Body;
        
        // 处理装箱后的类型转换（如int转object）
        if (propertyAccess is UnaryExpression unaryExpr && unaryExpr.NodeType == ExpressionType.Convert)
        {
            propertyAccess = unaryExpr.Operand;
        }

        var valueConstant = Expression.Constant(condition.Value, propertyAccess.Type);
        Expression comparisonExpr = null;

        switch (condition.Operator)
        {
            case FilterOperator.GreaterThanOrEqual:
                comparisonExpr = Expression.GreaterThanOrEqual(propertyAccess, valueConstant);
                break;
            case FilterOperator.Contains:
                var containsMethod = propertyAccess.Type.GetMethod("Contains", new[] { propertyAccess.Type });
                comparisonExpr = Expression.Call(propertyAccess, containsMethod, valueConstant);
                break;
            // 其他操作符逻辑
        }

        return Expression.Lambda<Func<T, bool>>(comparisonExpr, parameter);
    }
}

使用方式：

var condition = new FilterCondition<Data>
{
    PropertySelector = d => d.a,
    Operator = FilterOperator.GreaterThanOrEqual,
    Value = filter.MinValue
};

IQueryable<Data> data = db.Data.Where(FilterBuilder.BuildFilter(condition));

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