Wie kann ich die kombinieren von LINQ-Ausdrücken in ein?

Ich habe ein Formular mit mehreren Felder (Firmenname, PLZ, etc.) die es einem Benutzer ermöglicht, um die Suche für Unternehmen in einer Datenbank. Wenn der Benutzer Werte in mehr als einem Feld, dann muss ich die Suche über alle Felder. Ich bin mit LINQ zur Abfrage der Datenbank.

So weit ich es geschafft habe, zu schreiben, eine Funktion, die schaut auf Ihre Eingabe und schalten Sie ihn in eine Liste von Ausdrücken. Ich will nun zu drehen, dass die Liste in einem einzigen Ausdruck, die ich ausführen können, über die LINQ-provider.

Mein Erster Versuch war wie folgt

private Expression<Func<Company, bool>> Combine(IList<Expression<Func<Company, bool>>> expressions)
    {
        if (expressions.Count == 0)
        {
            return null;
        }
        if (expressions.Count == 1)
        {
            return expressions[0];
        }
        Expression<Func<Company, bool>> combined = expressions[0];
        expressions.Skip(1).ToList().ForEach(expr => combined = Expression.And(combined, expr));
        return combined;
    }

Aber dieser schlägt mit einer Ausnahme fehl-Nachricht entlang der Linien von "Der binary-operator Und ist nicht definiert...". Hat jemand eine Idee, was ich tun müssen, um zu kombinieren, diese Ausdrücke?

EDIT: Korrigiert die Zeile, wo ich vergessen hatte, weisen Sie das Ergebnis der and ' Ing die Ausdrücke zusammen, um eine variable. Danke für den Hinweis Leute.

InformationsquelleAutor gilles27 | 2009-12-17
  1. 9

    EDIT: Jason ' s Antwort ist jetzt voller als meiner war in Bezug auf die expression tree Zeug, so habe ich entnommen, dass bit. Aber, ich wollte zu verlassen:

    Ich nehme an, du verwendest diese für eine Where - Klausel... warum nicht einfach nennen, Wo mit jedem Ausdruck in die Reihe? Das sollte den gleichen Effekt haben:

    var query = ...;
foreach (var condition in conditions)
{
    query = query.Where(condition);
}
    • Skeet: combined eingegeben werden als Expression; Sie brauchen, um einige Arbeit zu tun, es zurückzugeben, wie ein Expression<Func<Company, bool>>.
    • Ich Stimme deinem ersten code ist einfacher zu verstehen, so werde ich dies die richtige Antwort. Aber ich bin eigentlich Los, um mit dem zweiten snippet wie dieses ist genau das was ich brauche - ich machte die Dinge viel zu Komplex, Dank Jon.
    • Ironischerweise war ich die Bearbeitung während diese beiden Kommentare wurden geschrieben - aber so wie es war in diesem zweiten Ausschnitt, der verwendet wurde, ich denke, ich werde es belassen, wie es ist 🙂
    InformationsquelleAutor Jon Skeet
  2. 25

    Können Sie Enumerable.Aggregat kombiniert mit Ausdruck.AndAlso. Hier ist eine generische version:

    Expression<Func<T, bool>> AndAll<T>(
    IEnumerable<Expression<Func<T, bool>>> expressions) {

    if(expressions == null) {
        throw new ArgumentNullException("expressions");
    }
    if(expressions.Count() == 0) {
        return t => true;
    }
    Type delegateType = typeof(Func<,>)
                            .GetGenericTypeDefinition()
                            .MakeGenericType(new[] {
                                typeof(T),
                                typeof(bool) 
                            }
                        );
    var combined = expressions
                       .Cast<Expression>()
                       .Aggregate((e1, e2) => Expression.AndAlso(e1, e2));
    return (Expression<Func<T,bool>>)Expression.Lambda(delegateType, combined);
}

    Ihre aktuelle code ist nie die Zuordnung zu combined:

    expr => Expression.And(combined, expr);

    gibt ein neues Expression das ist das Ergebnis der bitweisen und-Verknüpfung combined und expr aber nicht mutieren combined.

    • +1 für eine technisch großartige Antwort, vielen Dank. Ich habe akzeptiert, Jon ' s, wie es scheint, einfacher und auch seine Verwendung von Wo ist eigentlich das, was ich tun sollte.
    • Ja, wenn Sie nur es für sich das Prädikat in einem Where - Klausel, dann Jon, die Antwort ist der Weg zu gehen. Wenn Sie jemals brauchen eine allgemeinere version, meine version wird Euch helfen. 🙂
    InformationsquelleAutor jason
  3. 0

    Hier haben wir eine Allgemeine Frage zum kombinieren von Linq-Ausdrücke. Ich habe eine Allgemeine Lösung für dieses problem. Ich werde eine Antwort in Bezug auf das spezifische problem gepostet, obwohl es definitiv nicht der richtige Weg in solchen Fällen. Aber wenn einfache Lösungen nicht in Ihrem Fall, Sie können versuchen, diese Methode verwenden.

    Müssen Sie zuerst eine Bibliothek, bestehend aus 2 einfachen Funktionen. Sie verwenden System.Linq.Expressions.ExpressionVisitor dynamisch ändern Ausdrücken. Das entscheidende Merkmal ist die Vereinigung Parameter in der expression, so dass 2 Parameter mit dem gleichen Namen gemacht wurden, identisch (UnifyParametersByName). Der Verbleibende Teil wird ersetzt einen benannten parameter mit dem angegebenen Ausdruck (ReplacePar). Die Bibliothek ist mit MIT-Lizenz auf github: LinqExprHelper, aber Sie schreibt schnell etwas auf Ihrem eigenen.

    Die Bibliothek ermöglicht eine Recht einfache syntax für die Verknüpfung komplexer Ausdrücke. Sie können mischen inline-lambda-Ausdrücke, die sind schön zu Lesen, zusammen mit dem dynamischen Ausdruck Kreation und Zusammensetzung, die sehr fähig.

        private static Expression<Func<Company, bool>> Combine(IList<Expression<Func<Company, bool>>> expressions)
    {
        if (expressions.Count == 0)
        {
            return null;
        }

        //Prepare a master expression, used to combine other
        //expressions. It needs more input parameters, they will
        //be reduced later.
        //There is a small inconvenience here: you have to use
        //the same name "c" for the parameter in your input
        //expressions. But it may be all done in a smarter way.
        Expression <Func<Company, bool, bool, bool>> combiningExpr =
            (c, expr1, expr2) => expr1 && expr2;

        LambdaExpression combined = expressions[0];
        foreach (var expr in expressions.Skip(1))
        {
            //ReplacePar comes from the library, it's an extension
            //requiring `using LinqExprHelper`.
            combined = combiningExpr
                .ReplacePar("expr1", combined.Body)
                .ReplacePar("expr2", expr.Body);
        }
        return (Expression<Func<Company, bool>>)combined;
    }
    InformationsquelleAutor Jarekczek
Schreibe einen Kommentar