通用类的谓词builder

Question

我正在尝试创建一种方法，其中我将通过包含字段，比较和价值的过滤器列表。这是我现在的参数

public class QueryFilter
{
    public string Field { get; set; }
    public object Value { get; set; }   
    public string Comparer { get; set; }
}

，我创建了一种方法，该方法将根据传递的QueryFilter列表返回表达式。

public Expression<Func<TEntity, bool>> QueryFilterBuilder<TEntity>(List<QueryFilter> filters)
    {
        try
        {
            var predicate = PredicateBuilder.New<TEntity>(true);

            filters.ForEach(filter =>
            {
                switch (filter.Comparer.ToLower())
                {
                    case QueryFilterComparer.Eq: // equals
                        predicate = predicate.And(x => filter.Field == filter.value); // something like this
                        break;
                    case QueryFilterComparer.Ne: // not equal
                        // Add not equal filter logic here
                        break;
                    case QueryFilterComparer.Any: // any
                        break;
                    case QueryFilterComparer.Gt: // greater than
                        break;
                    case QueryFilterComparer.Gte: // greater than equal
                        break;
                    case QueryFilterComparer.Lt: // less than
                        break;
                    case QueryFilterComparer.Lte: // less than equal
                        break;
                    case QueryFilterComparer.Contains: // contains
                        break;
                    default:
                        break;
                };
            });

            return predicate;
        }
        catch (Exception)
        {
            throw;
        }
    }

问题是我不确定如何使用通用类实现此目标。可以这样做吗？

Answer 1

您可以使用Expression API这样实现此信息：

public static Expression<Func<TEntity, bool>> QueryFilterBuilder<TEntity> 
(List<QueryFilter> filters)
{
    Expression GetExpressionForQueryFilter(QueryFilter filter, Expression param)
        => filter.Comparer switch
        {
            QueryFilterComparer.Eq => Expression.Equal(GetField(filter.Field, param), Expression.Constant(filter.Value)),
            QueryFilterComparer.Ne => Expression.Not(Expression.Equal(GetField(filter.Field, param), Expression.Constant(filter.Value))),
            QueryFilterComparer.Any => throw new NotImplementedException(),
            QueryFilterComparer.Gt => throw new NotImplementedException(),
            QueryFilterComparer.Gte => throw new NotImplementedException(),
            QueryFilterComparer.Lt => throw new NotImplementedException(),
            QueryFilterComparer.Lte => throw new NotImplementedException(),
            QueryFilterComparer.Contains => throw new NotImplementedException(),
            _ => throw new ArgumentOutOfRangeException()
    };

    Expression GetField(string field, Expression param)
    => Expression.Field(param, typeof(TEntity).GetField(field) ?? throw new ArgumentOutOfRangeException());

    var parameter = Expression.Parameter(typeof(TEntity), "parameter");

    return Expression.Lambda<Func<TEntity, bool>>(filters.Aggregate(
        (Expression) Expression.Constant(true),
        (acc, next) => Expression.MakeBinary(ExpressionType.AndAlso, acc, GetExpressionForQueryFilter(next, parameter))),
    parameter);
}