如何按各种变量过滤？

Question

我一直在寻找解决问题的方法。所以，问题是如何过滤所有变量类型，如 int / double / decimal ...例如，我有 json 数据具有多个属性，例如 id、name、price、description ...我必须进行搜索适用于所有类型。现在，我只能查询 ("...") 字符串的字段。如何使 id/price(int / double / decimal) 成为可能？

private static Expression<Func<T, bool>> GetExpression<T>(string propertyName, string propertyValue)
{
    var parametr = Expression.Parameter(typeof(T));
    var property = Expression.Property(parametr, propertyName);
    var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });

    var objectContains = Expression.Constant(propertyValue, typeof(string));
    var objectEquals   = Expression.Equal(property, Expression.Constant(propertyValue));

    var constrantMethod = Expression.Call(property, containsMethod, objectContains);

    return Expression.Lambda<Func<T, bool>>(constrantMethod, parametr)
                .Or(Expression.Lambda<Func<T, bool>>(objectEquals, parametr));
}

public static IQueryable<T> ApplyFiltering<T>(this IQueryable<T> source, string propertyLabel, string propertyValue)
{
    if (string.IsNullOrEmpty(propertyLabel))
    {
       return source;
    }

    var propertyNames = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public)
                              .Where(property => property.PropertyType == typeof(string) && property.Name == propertyLabel)
                              .Select(property => property.Name);

    var predicate = PredicateBuilder.New<T>();

    foreach (var name in propertyNames)
    {
        predicate = predicate.Or(GetExpression<T>(name, propertyValue));
    }

    return source.Where(predicate);
}

Answer 1

我已将 API 更改为更通用，希望此实现能帮助您了解如何构建 ExpressionTree。

用法：

query = query.ApplyFiltering(new Dictionary<string, object>
{
    {"Id", "2"},
    {"StrValue", "st"},
    {"DoubleValue", "3.5"}
});

实施：

public static class FilterExtensions
{
    public static IQueryable<T> ApplyFiltering<T>(this IQueryable<T> source, IDictionary<string, object> values, bool isOr = true)
    {
        if (values.Count == 0)
            return source;

        var predicate = GeneratePredicate<T>(values, isOr, (p, v) => p.Contains(v));

        return source.Where(predicate);
    }

    public static Expression<Func<T, bool>> GeneratePredicate<T>(IDictionary<string, object> values, bool isOr, Expression<Func<string, string, bool>> stringPredicate)
    {
        var entityParam = Expression.Parameter(typeof(T), "e");

        Expression predicate = null;

        foreach (var pair in values)
        {
            var propPath = MakePropPath(entityParam, pair.Key);

            Expression propPredicate;

            if (pair.Value == null)
            {
                // Decide what to do with non-reference types
                if (!(propPath.Type.IsClass || propPath.Type.IsInterface))
                    continue;

                propPredicate = Expression.Equal(propPath, Expression.Constant(null, propPath.Type));
            }
            else
            {
                var convertType = propPath.Type;
                if (convertType.IsGenericType && convertType.GetGenericTypeDefinition() == typeof(Nullable<>))
                    convertType = convertType.GetGenericArguments()[0];

                var value = convertType == pair.Value.GetType()
                    ? pair.Value
                    : Convert.ChangeType(pair.Value, convertType);

                Expression valueExpression = Expression.Constant(value);

                if (stringPredicate != null && value is string)
                {
                    propPredicate = ExpressionReplacer.GetBody(stringPredicate, propPath, valueExpression);
                }
                else
                {
                    if (valueExpression.Type != propPath.Type)
                        valueExpression = Expression.Convert(valueExpression, propPath.Type);

                    propPredicate = Expression.Equal(propPath, valueExpression);
                }
            }   
            
            if (predicate == null)
                predicate = propPredicate;
            else
            {
                predicate = isOr ? Expression.OrElse(predicate, propPredicate) : Expression.AndAlso(predicate, propPredicate);
            }
        }

        if (predicate == null)
            predicate = Expression.Constant(true);

        return Expression.Lambda<Func<T, bool>>(predicate, entityParam);
    }

    static Expression MakePropPath(Expression objExpression, string path)
    {
        return path.Split('.').Aggregate(objExpression, Expression.PropertyOrField);
    }

    class ExpressionReplacer : ExpressionVisitor
    {
        readonly IDictionary<Expression, Expression> _replaceMap;

        public ExpressionReplacer(IDictionary<Expression, Expression> replaceMap)
        {
            _replaceMap = replaceMap ?? throw new ArgumentNullException(nameof(replaceMap));
        }

        public override Expression Visit(Expression node)
        {
            if (node != null && _replaceMap.TryGetValue(node, out var replacement))
                return replacement;
            return base.Visit(node);
        }

        public static Expression Replace(Expression expr, Expression toReplace, Expression toExpr)
        {
            return new ExpressionReplacer(new Dictionary<Expression, Expression> { { toReplace, toExpr } }).Visit(expr);
        }

        public static Expression Replace(Expression expr, IDictionary<Expression, Expression> replaceMap)
        {
            return new ExpressionReplacer(replaceMap).Visit(expr);
        }

        public static Expression GetBody(LambdaExpression lambda, params Expression[] toReplace)
        {
            if (lambda.Parameters.Count != toReplace.Length)
                throw new InvalidOperationException();

            return new ExpressionReplacer(Enumerable.Range(0, lambda.Parameters.Count)
                .ToDictionary(i => (Expression)lambda.Parameters[i], i => toReplace[i])).Visit(lambda.Body);
        }
    }
}

Answer 2

我使用属性类型并转换字符串值以匹配等于 testing. I modified the code for non-strings to use ToStringon the property or value as needed soContainswould still work, assuming you wanted to filter by contain on non-strings. I assumed no property would be a collection class, so onlyString.Contains 支持。

public static class TestExt {
    static MethodInfo stringContainsMI = typeof(string).GetMethod("Contains", new[] { typeof(string) });

    private static Expression<Func<T, bool>> GetExpression<T>(string propertyName, string propertyValue) {
        // p
        var pParm = Expression.Parameter(typeof(T), "p");
        // p.{propertyName}
        var propertyExpr = Expression.Property(pParm, propertyName);
        var propType = propertyExpr.Type;

        Expression propValConst;
        if (propType == typeof(string))
            // {propertyValue}
            propValConst = Expression.Constant(propertyValue);
        else
            // {propertyValue as propType}
            propValConst = Expression.Constant(Convert.ChangeType(propertyValue, propType));

        // p.{PropertyName} == {propertyValue}
        var equalsExpr = Expression.Equal(propertyExpr, propValConst);

        Expression propValAsStringExpr = Expression.Constant(propertyValue);
        Expression propertyAsStringExpr;
        if (propType == typeof(string))
            // p.{propertyName}
            propertyAsStringExpr = propertyExpr;
        else {
            var propToStringMI = propType.GetMethod("ToString", Type.EmptyTypes);
            // p.{propertyName}.ToString()
            propertyAsStringExpr = Expression.Call(propertyExpr, propToStringMI);
        }

        // p.{propertyName}.Contains({propertyValue}) or p.{propertyName}.ToString().Contains({propertyValue})
        var containsExpr = Expression.Call(propertyAsStringExpr, stringContainsMI, propValAsStringExpr);
        //  (p.{PropertyName} == {propertyValue}) || p.{propertyName}.Contains({propertyValue})
        var lambdaBody = Expression.OrElse(equalsExpr, containsExpr);

        // p => (p.{PropertyName} == {propertyValue}) || p.{propertyName}.Contains({propertyValue})
        return Expression.Lambda<Func<T, bool>>(lambdaBody, pParm);
    }

    public static IQueryable<T> ApplyFiltering<T>(this IQueryable<T> source, string propertyLabel, string propertyValue) {
            var predicate = GetExpression<T>(propertyLabel, propertyValue);

            return source.Where(predicate);
    }
}