Die Kombination von zwei Ausdrücken (Ausdruck<U<T, bool>>)

Gut, können Sie verwenden Expression.AndAlso /OrElse etc zu kombinieren, logische Ausdrücke, aber das problem ist, die Parameter; arbeiten Sie mit der gleichen ParameterExpression im expr1 und expr2? Wenn dem so ist, ist es einfacher:

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

Dies funktioniert auch gut, zu negieren einer einzigen operation:

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]);
}

Ansonsten, je nach dem LINQ-provider, die Sie vielleicht in der Lage sein, Sie zu kombinieren mit 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;
}

Irgendwo, ich habe einige code, der re-schreibt einen Ausdruck-Baum ersetzen von Knoten zu entfernen, die Notwendigkeit für Invoke, aber es ist ziemlich lang (und ich kann mich nicht erinnern, wo ich es verlassen habe...)

Generalisierte version wählt den einfachsten Weg:

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);
}

Ab .net 4.0. Es ist die ExpressionVistor Klasse, die ermöglicht Ihnen das erstellen von Ausdrücken, die EF sicher.

    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);
        }
    }

InformationsquelleAutor Marc Gravell

Joe Albahari (Autor von C# 3.0 in a Nutshell und LINQPad) schrieb ein Programm namens PredicateBuilder verwendet werden können und-UND ODER-Funktionen zusammen.

http://www.albahari.com/nutshell/predicatebuilder.aspx

Während es funktioniert Funktionen es ist open source, so können Sie check it out und sehen, wie es funktioniert.

InformationsquelleAutor Cameron MacFarland

Schlage ich vor, eine weitere Verbesserung PredicateBuilder und ExpressionVisitor Lösungen. Ich nannte es UnifyParametersByName und Sie können finden Sie in der MIT Bibliothek von mir: LinqExprHelper. Es erlaubt die Kombination von beliebigen lambda-Ausdrücke. In der Regel die Frage, Prädikat Ausdruck, aber diese Idee erstreckt sich auch auf die Projektion Ausdrücken, wie gut.

Den folgenden code beschäftigt eine Methode ExprAdres schafft eine komplizierte parametrisierten Ausdruck, die Verwendung von inline-lambda. Dieser komplizierte Ausdruck kodiert nur einmal, und wieder, Dank der LinqExprHelper mini-Bibliothek.

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);
    }
}

- Und dies ist der Teilausdruck Gebäude-code:

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();
}

Was ich versucht habe zu erreichen, war parametrisierten Abfragen, ohne zu müssen zu kopieren und zu kleben und mit der Fähigkeit zu verwenden, inline-lambdas, die sind so schön. Ohne all diese Helfer-expression Zeug, würde ich gezwungen werden, zu erstellen, die gesamte Abfrage in einem Rutsch.

InformationsquelleAutor Jarekczek

Ich denke, das funktioniert gut, nicht wahr ?

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));

InformationsquelleAutor Céline