C # рефакторинг лямбда-выражений

Question

У меня есть несколько Expression<Func<User,bool>> выражений, которые разделяют свойства. Например,

Expression<Func<User, bool>> e1 = 
  (User u) => u.IsActive && u.Group != "PROCESS" && u.Name != null;
Expression<Func<User, bool>> e2 = 
  (User u) => u.IsActive && u.Group != "PROCESS" && u.Name != "A";
Expression<Func<User, bool>> e3 = 
  (User u) => u.IsActive && u.Group != "PROCESS" && u.Name != "B";

Есть ли простой способ поместить u.IsActive && u.Group != "PROCESS" в переменную и использовать его в e1, e2 и e3? Отредактировано: И я все еще хочу то же самое дерево.

Кажется, я могу сделать это, построив выражение с Expression.Lambda<Func<User, bool>>(BinaryExpression.AndAlso( и т. Д ... Но вместо того, чтобы упростить мой код, это усложнило чтение.

Answer 1

Проблема с лямбда-выражениями заключается в том, что они неизменны, и вы не можете легко заменить параметры лямбда-выражения. Моей первоначальной идеей было сделать что-то вроде этого ( к сожалению, это не сработает ):

public static class ExpressionExtesions
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> baseCondition, Expression<Func<T, bool>> additionalCondition)
    {
        var and = Expression.AndAlso(baseCondition.Body, additionalCondition.Body);
        return Expression.Lambda<Func<T, bool>>(and, baseCondition.Parameters);  // additionalCondition.Body still uses its own parameters so this fails on Compile()
    }
}

и используйте в коде:

Expression<Func<User, bool>> e = usr => usr.IsActive && usr.Group != "PROCESS";

var e1 = e.And(u => u.Name != null);
var e2 = e.And(u => u.Name != "A");
var e3 = e.And(u => u.Name != "B");

Возможное решение

Вы можете попробовать использовать один из проектов, направленных на реализацию построителей выражений. Я не использовал ни одного из них, но Google дает много ссылок, например:

• Metalinq
• LINQ: СОЗДАНИЕ УДОБНОГО ПРОВАЙДЕРА - ЧАСТЬ II
• Работа с неизменными деревьями выражения Линка

Другой подход

Если вы используете эти выражения в LINQ для фильтрации значений, вы можете использовать другой подход (не объединять выражения, а объединять фильтры):

var activeUsers = allUsers.Where(usr => usr.IsActive && usr.Group != "PROCESS");

var usersAll = activeUsers.Where(u => u.Name != null);
var usersNotA = activeUsers.Where(u => u.Name != "A");
var usersNotB = activeUsers.Where(u => u.Name != "B");

Answer 2

Я полагаю, что нет более чистого способа сделать это для вашего случая. Вы можете использовать BinaryExpression, как вы упомянули. Вы можете инкапсулировать вызовы BinaryExpression и Expression.Lambda в метод и вызывать его вместо этого (например, PredicateBuilder.And ), но ни один из них не является настолько чистым, как текущий синтаксис IMO.

Answer 3

Я не думаю, что обязательно найдется лучший ответ, чем тот, который вы уже используете. Как упоминает Мехрдад, вам нужно будет построить более глубокое дерево, используя BinaryExpression, и я думаю, что это будет шагом назад в удобочитаемости вашего текущего кода.

В зависимости от вашего использования, вы можете сохранить некоторые строки кода, используя семантику замыкания и делая что-то вроде этого:

string name = null;

Expression<Func<User, bool>> e = 
  (User u) => u.IsActive && u.Group != "PROCESS" && u.Name != name;

var expr = e.Compile();

name = "A";
var result = expr.Invoke(u); //True (assume u.Name = "B")

name = "B";
result = expr.Invoke(u); //False

... но будет ли это использоваться, будет зависеть от того, что вы делаете с скомпилированным делегатом. Может быть, совершенно бесполезен для вас, но стоит упомянуть на всякий случай!

Answer 4

var test = new Func<User, bool>(u=> u.IsActive && u.Group != "PROCESS");
Expression<Func<User, bool>> e1 = (User u) => test(u) && u.Name != null;
Expression<Func<User, bool>> e2 = (User u) => test(u) && u.Name != "A";
Expression<Func<User, bool>> e3 = (User u) => test(u) && u.Name != "B";