Combinando duas expressões (Expressão <Func <T, bool >>)

249

Eu tenho duas expressões do tipo Expression<Func<T, bool>>e quero levar para OR, AND ou NOT desses e obter uma nova expressão do mesmo tipo

Expression<Func<T, bool>> expr1;
Expression<Func<T, bool>> expr2;

...

//how to do this (the code below will obviously not work)
Expression<Func<T, bool>> andExpression = expr AND expr2
BjartN
fonte
8
Post muito útil que recebi do Google: LINQ to Entities: Combinando Predicados
Thomas CG de Vilhena

Respostas:

331

Bem, você pode usar Expression.AndAlso/ OrElseetc para combinar expressões lógicas, mas o problema são os parâmetros; você está trabalhando com o mesmo ParameterExpressionem expr1 e expr2? Nesse caso, é mais fácil:

var body = Expression.AndAlso(expr1.Body, expr2.Body);
var lambda = Expression.Lambda<Func<T,bool>>(body, expr1.Parameters[0]);

Isso também funciona bem para negar uma única operação:

static Expression<Func<T, bool>> Not<T>(
    this Expression<Func<T, bool>> expr)
{
    return Expression.Lambda<Func<T, bool>>(
        Expression.Not(expr.Body), expr.Parameters[0]);
}

Caso contrário, dependendo do provedor LINQ, você poderá combiná-los com Invoke:

// OrElse is very similar...
static Expression<Func<T, bool>> AndAlso<T>(
    this Expression<Func<T, bool>> left,
    Expression<Func<T, bool>> right)
{
    var param = Expression.Parameter(typeof(T), "x");
    var body = Expression.AndAlso(
            Expression.Invoke(left, param),
            Expression.Invoke(right, param)
        );
    var lambda = Expression.Lambda<Func<T, bool>>(body, param);
    return lambda;
}

Em algum lugar, tenho um código que reescreve uma árvore de expressão que substitui os nós para remover a necessidade Invoke, mas é bastante demorado (e não me lembro onde o deixei ...)


Versão generalizada que escolhe a rota mais simples:

static Expression<Func<T, bool>> AndAlso<T>(
    this Expression<Func<T, bool>> expr1,
    Expression<Func<T, bool>> expr2)
{
    // need to detect whether they use the same
    // parameter instance; if not, they need fixing
    ParameterExpression param = expr1.Parameters[0];
    if (ReferenceEquals(param, expr2.Parameters[0]))
    {
        // simple version
        return Expression.Lambda<Func<T, bool>>(
            Expression.AndAlso(expr1.Body, expr2.Body), param);
    }
    // otherwise, keep expr1 "as is" and invoke expr2
    return Expression.Lambda<Func<T, bool>>(
        Expression.AndAlso(
            expr1.Body,
            Expression.Invoke(expr2, param)), param);
}

A partir do .NET 4.0, existe a ExpressionVisitorclasse que permite criar expressões que são seguras pelo EF.

    public static Expression<Func<T, bool>> AndAlso<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.AndAlso(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);
        }
    }
Marc Gravell
fonte
Ei Marc, tentei sua primeira sugestão, no seu primeiro bloco de código acima, mas quando passo a expressão "lambda" <func <T, bool >> resulta no método Where, recebo um erro dizendo que o parâmetro é fora do escopo? qualquer ideia? Cheers
Andy
1
+1 na versão generalizada funciona como um encanto, eu usei. E em vez de andalso, pensei que o linq to sql não suporta andalso?
Maslow
2
@ Maslow - aqui está um reescritor que pode alinhar as árvores para salvar Invoke: stackoverflow.com/questions/1717444/…
Marc Gravell
1
@ Aron agora observe a data: o .NET framework visitor ( ExpressionVisitor) não existia naquela época; Eu tenho um exemplo relacionado no stackoverflow a partir de uma data semelhante em que implementa o visitante manualmente: é muito código.
Marc Gravell
1
@ MarkGravell, estou usando sua primeira solução para combinar minhas expressões, e tudo está funcionando bem mesmo na estrutura da entidade. Então, quais seriam os benefícios de usar a última solução?
johnny 5
62

Você pode usar Expression.AndAlso / OrElse para combinar expressões lógicas, mas é necessário garantir que as ParameterExpressions sejam as mesmas.

Eu estava tendo problemas com a EF e o PredicateBuilder, então criei o meu próprio sem recorrer ao Invoke, que eu poderia usar assim:

var filterC = filterA.And(filterb);

Código fonte do meu PredicateBuilder:

public static class PredicateBuilder {

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> a, Expression<Func<T, bool>> b) {    

        ParameterExpression p = a.Parameters[0];

        SubstExpressionVisitor visitor = new SubstExpressionVisitor();
        visitor.subst[b.Parameters[0]] = p;

        Expression body = Expression.AndAlso(a.Body, visitor.Visit(b.Body));
        return Expression.Lambda<Func<T, bool>>(body, p);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> a, Expression<Func<T, bool>> b) {    

        ParameterExpression p = a.Parameters[0];

        SubstExpressionVisitor visitor = new SubstExpressionVisitor();
        visitor.subst[b.Parameters[0]] = p;

        Expression body = Expression.OrElse(a.Body, visitor.Visit(b.Body));
        return Expression.Lambda<Func<T, bool>>(body, p);
    }   
}

E a classe de utilitário para substituir os parâmetros em um lambda:

internal class SubstExpressionVisitor : System.Linq.Expressions.ExpressionVisitor {
        public Dictionary<Expression, Expression> subst = new Dictionary<Expression, Expression>();

        protected override Expression VisitParameter(ParameterExpression node) {
            Expression newValue;
            if (subst.TryGetValue(node, out newValue)) {
                return newValue;
            }
            return node;
        }
    }
Adam Tegen
fonte
Essa solução foi a única que me permitiu ter x => x.Property == Value combinado com arg => arg.Property2 == Value. Adereços principais, um pouco concisos e confusos, mas funciona, então não vou reclamar. Kudos Adam :-)
VulgarBinary
Esta é uma otima soluçao.
Aaron Stainback
Adam, isso resolveu um problema muito irritante que eu estava tendo usando o provedor Linq do modelo de objeto de cliente do SharePoint - obrigado por postá-lo.
Christopher McAtackney
Isso funcionou para mim! Eu tinha procurado por uma variedade de soluções, bem como pelo construtor de predicados, e nada funcionou até isso. Obrigado!
#
Este é um maravilhoso pedaço de código. Eu não poderia encontrar um lugar para ajustar o código, copiar e colar e é isso :)
Tolga Evcimen
19

Se seu provedor não suportar Invoke e você precisar combinar duas expressões, poderá usar um ExpressionVisitor para substituir o parâmetro na segunda expressão pelo parâmetro na primeira expressão.

class ParameterUpdateVisitor : ExpressionVisitor
{
    private ParameterExpression _oldParameter;
    private ParameterExpression _newParameter;

    public ParameterUpdateVisitor(ParameterExpression oldParameter, ParameterExpression newParameter)
    {
        _oldParameter = oldParameter;
        _newParameter = newParameter;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (object.ReferenceEquals(node, _oldParameter))
            return _newParameter;

        return base.VisitParameter(node);
    }
}

static Expression<Func<T, bool>> UpdateParameter<T>(
    Expression<Func<T, bool>> expr,
    ParameterExpression newParameter)
{
    var visitor = new ParameterUpdateVisitor(expr.Parameters[0], newParameter);
    var body = visitor.Visit(expr.Body);

    return Expression.Lambda<Func<T, bool>>(body, newParameter);
}

[TestMethod]
public void ExpressionText()
{
    string text = "test";

    Expression<Func<Coco, bool>> expr1 = p => p.Item1.Contains(text);
    Expression<Func<Coco, bool>> expr2 = q => q.Item2.Contains(text);
    Expression<Func<Coco, bool>> expr3 = UpdateParameter(expr2, expr1.Parameters[0]);

    var expr4 = Expression.Lambda<Func<Recording, bool>>(
        Expression.OrElse(expr1.Body, expr3.Body), expr1.Parameters[0]);

    var func = expr4.Compile();

    Assert.IsTrue(func(new Coco { Item1 = "caca", Item2 = "test pipi" }));
}
Francis
fonte
1
Isso resolveu meu problema específico, onde a outra solução resultou na mesma exceção. Obrigado.
Shaun Wilson
1
Esta é uma otima soluçao.
Aaron Stainback
3

Nada de novo aqui, mas casou-se com esta resposta com esta resposta e ligeiramente reformulado-lo de modo que mesmo eu entendo o que está acontecendo:

public static class ExpressionExtensions
{
    public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {
        ParameterExpression parameter1 = expr1.Parameters[0];
        var visitor = new ReplaceParameterVisitor(expr2.Parameters[0], parameter1);
        var body2WithParam1 = visitor.Visit(expr2.Body);
        return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, body2WithParam1), parameter1);
    }

    private class ReplaceParameterVisitor : ExpressionVisitor
    {
        private ParameterExpression _oldParameter;
        private ParameterExpression _newParameter;

        public ReplaceParameterVisitor(ParameterExpression oldParameter, ParameterExpression newParameter)
        {
            _oldParameter = oldParameter;
            _newParameter = newParameter;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (ReferenceEquals(node, _oldParameter))
                return _newParameter;

            return base.VisitParameter(node);
        }
    }
}
Dejan
fonte
Eu estava tendo dificuldades para entender o conceito, e sua combinação de algumas outras respostas ajudou a clicar para mim. Obrigado!
Kevin M. Lapio 17/04
2

Eu precisava alcançar os mesmos resultados, mas usando algo mais genérico (como o tipo não era conhecido). Graças à resposta de Marc, finalmente descobri o que estava tentando alcançar:

    public static LambdaExpression CombineOr(Type sourceType, LambdaExpression exp, LambdaExpression newExp) 
    {
        var parameter = Expression.Parameter(sourceType);

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

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

        var delegateType = typeof(Func<,>).MakeGenericType(sourceType, typeof(bool));
        return Expression.Lambda(delegateType, Expression.Or(left, right), parameter);
    }
VorTechS
fonte
1

Sugiro mais uma melhoria para o PredicateBuilder e ExpressionVisitorsoluções. Eu chamei UnifyParametersByNamee você pode encontrá-lo na minha biblioteca do MIT: LinqExprHelper . Permite combinar expressões lambda arbitrárias. Geralmente, as perguntas são feitas sobre a expressão de predicado, mas essa idéia se estende também às expressões de projeção.

O código a seguir emprega um método ExprAdresque cria uma expressão parametrizada complicada, usando lambda embutido. Essa expressão complicada é codificada apenas uma vez e depois reutilizada, graças à LinqExprHelpermini-biblioteca.

public IQueryable<UbezpExt> UbezpFull
{
    get
    {
        System.Linq.Expressions.Expression<
            Func<UBEZPIECZONY, UBEZP_ADRES, UBEZP_ADRES, UbezpExt>> expr =
            (u, parAdrM, parAdrZ) => new UbezpExt
            {
                Ub = u,
                AdrM = parAdrM,
                AdrZ = parAdrZ,
            };

        // From here an expression builder ExprAdres is called.
        var expr2 = expr
            .ReplacePar("parAdrM", ExprAdres("M").Body)
            .ReplacePar("parAdrZ", ExprAdres("Z").Body);
        return UBEZPIECZONY.Select((Expression<Func<UBEZPIECZONY, UbezpExt>>)expr2);
    }
}

E este é o código de construção da subexpressão:

public static Expression<Func<UBEZPIECZONY, UBEZP_ADRES>> ExprAdres(string sTyp)
{
    return u => u.UBEZP_ADRES.Where(a => a.TYP_ADRESU == sTyp)
        .OrderByDescending(a => a.DATAOD).FirstOrDefault();
}

O que eu tentei realizar foi realizar consultas parametrizadas sem a necessidade de copiar e colar e com a capacidade de usar lambdas em linha, que são muito bonitas. Sem todas essas coisas de expressão auxiliar, eu seria forçado a criar uma consulta inteira de uma só vez.

Jarekczek
fonte
-7

Eu acho que isso funciona bem, não é?

Func<T, bool> expr1 = (x => x.Att1 == "a");
Func<T, bool> expr2 = (x => x.Att2 == "b");
Func<T, bool> expr1ANDexpr2 = (x => expr1(x) && expr2(x));
Func<T, bool> expr1ORexpr2 = (x => expr1(x) || expr2(x));
Func<T, bool> NOTexpr1 = (x => !expr1(x));
Céline
fonte
1
isso não pode ser usado em LINQ to SQL, por exemplo
Romain Vergnory