.net core - объединить список функций с или на одну функцию - PullRequest
Новая
       22

.net core - объединить список функций с или на одну функцию

0 голосов
/ 05 сентября 2018

Здравствуйте, я пытаюсь сгенерировать один Func из списка, объединенного или. 

var funcs = new List<Func<User, bool>>()
{
    (u) => u.Id.Equals(entityToFind.Id),
    (u) => u.UserName == entityToFind.UserName,
    (u) => u.Email == entityToFind.Email
};

//TODO: Some magic that funs is euqaly to that:

Func<User, bool> func =  (u) => u.Id.Equals(entityToFind.Id) || u.UserName == entityToFind.UserName || u.Email == entityToFind.Email;

Я тоже пробовал это с выражениями, вот так: 

private Dictionary<string, Expression<Func<User, bool>>>     private Dictionary<string, Expression<Func<User, bool>>> test(User entityToFind)
{
    return new Dictionary<string, Expression<Func<User, bool>>>() {
        {"Id", (u) => u.Id.Equals(entityToFind.Id) },
        {"Name", (u) => u.UserName == entityToFind.UserName },
        {"Email", (u) => u.Email == entityToFind.Email }
    };
}


public static Expression<Func<T, bool>> ToOrExpression<T>(this Dictionary<string, Expression<Func<T, bool>>> dict)
{
    var expressions = dict.Values.ToList();
    if (!expressions.Any())
    {
        return t => true;
    }

    var delegateType = typeof(Func<T, bool>)
        .GetGenericTypeDefinition()
        .MakeGenericType(new[]
            {
                typeof(T),
                typeof(bool)
            }
        );

    var tfd = Expression.OrElse(expressions[0], expressions[1]);

    var combined = expressions
        .Cast<Expression>()
        .Aggregate( (e1, e2) => Expression.OrElse(e1, e2) );

    return (Expression<Func<T, bool>>)Expression.Lambda(delegateType, combined);
}


test(entityToFind).ToOrExpression();

Но там я получу следующую ошибку:

Бинарный оператор OrElse не определен для типов 'System.Func 2[Models.User,System.Boolean]' and 'System.Func 2 [Models.User, System.Boolean]'

1 Ответ

0 голосов
/ 05 сентября 2018

Хотя вы можете создать метод-обертку для объединения набора Func s, поскольку вы используете Entity Framework, это приведет к загрузке всего набора данных в память и выполнению локального поиска. Вместо этого вам следует использовать Expression<Func<T, bool>>.

К счастью Марк Гравелл уже написал небольшой фрагмент кода для объединения выражений . Ваш вопрос является строго дублирующим, потому что вы хотите объединить более двух вместе, но это довольно просто с небольшим Linq. Итак, давайте сначала начнем с ваших выражений, код почти не меняется: 

var expressions = new List<Expression<Func<User, bool>>>()
{
    (u) => u.Id.Equals(entityToFind.Id),
    (u) => u.UserName == entityToFind.UserName,
    (u) => u.Email == entityToFind.Email
};

Теперь используя код Марка и изменив его на or вместо and: 

public static class ExpressionExtensions
{
    public static Expression<Func<T, bool>> OrElse<T>(
        this Expression<Func<T, bool>> expr1,
        Expression<Func<T, bool>> expr2)
    {
        var parameter = Expression.Parameter(typeof(T));

        var leftVisitor = new ReplaceExpressionVisitor(expr1.Parameters[0], parameter);
        var left = leftVisitor.Visit(expr1.Body);

        var rightVisitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);
        var right = rightVisitor.Visit(expr2.Body);

        return Expression.Lambda<Func<T, bool>>(
            Expression.OrElse(left, right), parameter);
    }

    private class ReplaceExpressionVisitor
    : ExpressionVisitor
    {
        private readonly Expression _oldValue;
        private readonly Expression _newValue;

        public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
        {
            _oldValue = oldValue;
            _newValue = newValue;
        }

        public override Expression Visit(Expression node)
        {
            if (node == _oldValue)
                return _newValue;
            return base.Visit(node);
        }
    }
}

Нет, вы комбинируете выражения с методом Linq Aggregate: 

var combinedExpression = expressions.Aggregate((x, y) => x.OrElse(y));

И используйте что-то вроде этого: 

var result = db.Things.Where(combinedExpression);
...