Как создать построитель выражений в .NET

Question

Я написал код, позволяющий фильтровать продукты на нашем сайте, и у меня довольно неприятный запах кода.Пользователь может выбрать 1- * из этих фильтров, что означает, что мне нужно быть конкретным с предложением WHERE.

Я думаю, что я ищу способ построения лямбда-выражения, поэтому для каждого фильтра яможет «изменить» мое предложение WHERE - но я не уверен, как это сделать в .NET, и должен быть способ.

Код в его текущем состоянии (эффективно закодированный, а не динамический, будетболь, чтобы добавить больше параметров фильтра).

public static class AgeGroups
{
    public static Dictionary<string, int> Items = new Dictionary<string, int>(){
        { "Modern (Less than 10 years old)", 1 },
        { "Retro (10 - 20 years old)", 2 },
        { "Vintage(20 - 70 years old)", 3 },
        { "Antique(70+ years old)", 4 }
    };

    public static IQueryable<ProductDTO> FilterAgeByGroup(IQueryable<ProductDTO> query, List<string> filters)
    {
        var values = new List<int>();
        var currentYear = DateTime.UtcNow.Year;
        foreach (var key in filters)
        {
            var matchingValue = Items.TryGetValue(key, out int value);

            if (matchingValue)
            {
                values.Add(value);
            }
        }

        if (Utility.EqualsIgnoringOrder(values, new List<int> { 1 }))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 10);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 2 }))
        {
            query = query.Where(x => x.YearManufactured <= currentYear - 10 && x.YearManufactured >= currentYear - 20);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 3 }))
        {
            query = query.Where(x => x.YearManufactured <= currentYear - 20 && x.YearManufactured >= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 4 }))
        {
            query = query.Where(x => x.YearManufactured <= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 2}))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 20);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 3 }))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 10 || (x.YearManufactured <= currentYear - 20 && x.YearManufactured >= currentYear - 70));
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 4 }))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 10 ||  x.YearManufactured <= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 2, 3 }))
        {
            query = query.Where(x => x.YearManufactured <= currentYear - 10 && x.YearManufactured >= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 2, 4 }))
        {
            query = query.Where(x => (x.YearManufactured <= currentYear - 10 && x.YearManufactured >= currentYear - 20) 
                                     || x.YearManufactured <= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 2, 3 }))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 2, 4 }))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 20 || x.YearManufactured <= currentYear - 70);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 2, 3, 4}))
        {
            query = query.Where(x => x.YearManufactured <= currentYear - 10);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 3, 4}))
        {
            query = query.Where(x => x.YearManufactured >= currentYear - 10 || x.YearManufactured <= 20);
        }
        else if (Utility.EqualsIgnoringOrder(values, new List<int> { 1, 2, 3, 4 }))
        {
            // all
        }
        return query;
    }
}

Answer 1

Я бы предложил динамически построить выражение, которое вы собираетесь передать в Where (как в ответ Алексея Андреева ; но без использования каких-либо сгенерированных компилятором выражений, только фабричные методы в System.Linq.Expressions.Expression.

Сначала определите свой исходный словарь со значением кортежа минимального и максимального возраста для каждого критерия:

// using static System.Linq.Expressions.Expression

public static Dictionary<string, (int code, int? min, int? max)> Items = new Dictionary<string, (int code, int? min, int? max)>(){
    { "Modern (Less than 10 years old)", (1, null, 10) },
    { "Retro (10 - 20 years old)", (2, 10, 20) },
    { "Vintage(20 - 70 years old)", (3, 20, 70) },
    { "Antique(70+ years old)", (4, 70, null) }
};

Затем вы можете динамически построить предикат, добавляя условия на основе переданного значения.фильтры и критерии их соответствия:

public static IQueryable<ProductDTO> FilterAgeByGroup(
    IQueryable<ProductDTO> query, 
    List<string> filters)
{
    var criteria = filters
        .Select(filter => {
            Items.TryGetValue(filter, out var criterion);
            return criterion; // if filter is not in Items.Keys, code will be 0
        })
        .Where(criterion => criterion.code > 0) // excludes filters not matched in Items
        .ToList();

    if (!criteria.Any()) { return query; }

    var type = typeof(ProductDTO);
    var x = Parameter(t);

    // creates an expression that represents the number of years old this ProductDTO is:
    // 2019 - x.YearManufactured
    var yearsOldExpr = Subtract(
        Constant(DateTime.UtcNow.Year),
        Property(x, t.GetProperty("YearManufactured"))
    );

    var filterExpressions = new List<Expression>();

    foreach (var criterion in criteria) {
        Expression minExpr = null;
        if (criterion.min != null) {
            // has to be at least criteria.min years old; eqivalent of:
            // 2019 - x.YearManufactured >= 10
            minExpr = GreaterThanOrEqual(
                yearsOldExpr,
                Constant(criterion.min)
            );
        }

        Expression maxExpr = null;
        if (criterion.max != null) {
            // has to be at least criteria.max years old; equivalent of
            // 2019 - x.YearManufactured <= 20
            maxExpr = LessThanOrEqual(
                yearsOldExpr,
                Constant(criterion.max)
            )
        }

        if (minExpr != null && maxExpr != null) {
            filterExpressions.Add(AndAlso(minExpr, maxExpr));
        } else {
            filterExpressions.Add(minExpr ?? maxExpr); // They can't both be null; we've already excluded that possibility above
        }
    }

    Expression body = filterExpressions(0);
    foreach (var filterExpression in filterExpressions.Skip(1)) {
        body = OrElse(body, filterExpression);
    }
    return query.Where(
        Lambda<Func<ProductDTO, bool>>(body, x)
    );
}

Answer 2

Я недавно столкнулся с этой проблемой сам.С помощью другого вопроса о SO я нашел http://www.albahari.com/nutshell/predicatebuilder.aspx. По сути, вы хотите создать предикат и передать его в предложение where вашего запроса.

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> where1, 
     Expression<Func<T, bool>> where2)
{
    InvocationExpression invocationExpression = Expression.Invoke(where2, 
         where1.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>(Expression.OrElse(where1.Body, 
         invocationExpression), where1.Parameters);
}

public static IQueryable<ProductDTO> FilterAgeByGroup(IQueryable<ProductDTO> query,  
   List<string> filters, int currentYear)
{
    var values = new HashSet<int>();
    //Default value
    Expression<Func<ProductDTO, bool>> predicate = (ProductDTO) => false;

    foreach (var key in filters)
    {
        var matchingValue = Items.TryGetValue(key, out int value);

        if (matchingValue)
        {
            values.Add(value);
        }
    }

    if (values.Count == 0)
        return query;

    if (values.Contains(1))
    {
        predicate = predicate.Or(x => x.YearManufactured >= currentYear - 10);
    }

    if (values.Contains(2))
    {
        predicate = predicate.Or(x => x.YearManufactured <= currentYear - 10 && 
            x.YearManufactured >= currentYear - 20);
    }

    if (values.Contains(3))
    {
        predicate = predicate.Or(x => x.YearManufactured <= currentYear - 20 && 
            x.YearManufactured >= currentYear - 70);
    }

    if (values.Contains(4))
    {
        predicate = predicate.Or(x => x.YearManufactured <= currentYear - 70);
    }

    return query.Where(predicate);
}

Answer 3

Используя LINQKit , вы можете легко комбинировать предикаты.Кроме того, нет никаких оснований для перевода filters List в другой List, просто чтобы обработать их, как только вы сможете их объединить, вы просто добавляете каждый переданный фильтр.

public static class AgeGroups {
    public static Dictionary<string, int> Items = new Dictionary<string, int>(){
        { "Modern (Less than 10 years old)", 1 },
        { "Retro (10 - 20 years old)", 2 },
        { "Vintage(20 - 70 years old)", 3 },
        { "Antique(70+ years old)", 4 }
    };

    public static IQueryable<ProductDTO> FilterAgeByGroup(IQueryable<ProductDTO> query, List<string> filters) {
        var currentYear = DateTime.UtcNow.Year;

        var pred = PredicateBuilder.New<ProductDTO>();
        foreach (var fs in filters) {
            if (Items.TryGetValue(fs, out var fv)) {
                switch (fv) {
                    case 1:
                        pred = pred.Or(p => currentYear-p.YearManufactured < 10);
                        break;
                    case 2:
                        pred = pred.Or(p => 10 <= currentYear-p.YearManufactured && currentYear-p.YearManufactured  <= 20);
                        break;
                    case 3:
                        pred = pred.Or(p => 20 <= currentYear-p.YearManufactured && currentYear-p.YearManufactured  <= 70);
                        break;
                    case 4:
                        pred = pred.Or(p => 70 <= currentYear-p.YearManufactured);
                        break;
                }
            }
        }

        return query.Where(pred);
    }
}

Answer 4

Похоже, вы столкнулись с комбинаторным взрывом.Вы можете объявлять простые случаи статически с помощью измененной коллекции Items:

static Dictionary<string, Expression<Func<int, int, bool>>> Items
   = new Dictionary<string, Expression<Func<int, int, bool>>>
{
    {
      "Modern (Less than 10 years old)",
      (yearManufactured, currentYear) => yearManufactured >= currentYear - 10
    },
    {
      "Retro (10 - 20 years old)",
      (yearManufactured, currentYear) => yearManufactured <= currentYear - 10 && yearManufactured >= currentYear - 20
    },
    {
      "Vintage(20 - 70 years old)",
      (yearManufactured, currentYear) => yearManufactured <= currentYear - 20 && yearManufactured >= currentYear - 70
    },
    {
      "Antique(70+ years old)",
      (yearManufactured, currentYear) => yearManufactured <= currentYear - 70
    }
};

Теперь вы можете динамически комбинировать ваши простые случаи с выражением Linq Expression OrElse.Попробуйте этот код:

public static IQueryable<ProductDTO> FilterAgeByGroup(
  IQueryable<ProductDTO> query, List<string> filters)
{
    var conditions = new List<Expression>();
    foreach (var key in filters)
        if (Items.TryGetValue(key, out Expression<Func<int, int, bool>> value))
            conditions.Add(value);

    // return as is if there no conditions
    if (!conditions.Any())
        return query;

    var x = Expression.Parameter(typeof(ProductDTO), "x");
    var yearManufactured = Expression.PropertyOrField(x, "YearManufactured");
    var currentYear = Expression.Constant(DateTime.UtcNow.Year);
    var body = conditions.Aggregate(
        (Expression) Expression.Constant(false), // ignore item by default
        (c, n) => Expression.OrElse(c, Expression.Invoke(n, yearManufactured, currentYear)));

    var lambda = Expression.Lambda<Func<ProductDTO, bool>>(body, x);
    return query.Where(lambda);
}