Kombinieren Sie zwei Linq, lambda-Ausdrücke

So logisch, was wollen wir in der Lage sein zu tun ist, erstellen Sie eine neue lambda in denen die parameter der Eingabe, um die erste Funktion, und ein Körper, ruft die erste Funktion, die parameter und übergibt das Ergebnis als parameter an die zweite Funktion, und gibt dann das.

Wir können zu replizieren, die leicht genug mit Expression Objekte:

public static Expression<Func<T1, T3>> Combine<T1, T2, T3>(
    Expression<Func<T1, T2>> first,
    Expression<Func<T2, T3>> second)
{
    var param = Expression.Parameter(typeof(T1), "param");
    var body = Expression.Invoke(second, Expression.Invoke(first, param));
    return Expression.Lambda<Func<T1, T3>>(body, param);
}

Traurig, EF und die meisten anderen Abfrage-Anbieter nicht wirklich wissen, was zu tun und wird nicht richtig funktionieren. Wann immer Sie Treffer mit einem Invoke Ausdruck, die Sie in der Regel nur eine Ausnahme werfen Art. Einige kann behandeln es aber. In der Theorie alle Informationen, die Sie benötigen ist es, wenn Sie geschrieben werden mit der Robustheit, um auf Sie.

Was wir jedoch tun kann ist, aus konzeptioneller Sicht, ersetzen Sie jede Instanz der ersten lambda-parameter in lambda-Körper mit dem parameter eine neue lambda, die wir schaffen, und dann ersetzen Sie alle Instanzen von der zweiten lambda-parameter in der zweiten lambda-Ausdruck mit den neuen body von der ersten lambda. Technisch, wenn diese Ausdrücke Nebeneffekte haben, und diese Parameter werden verwendet, mehr als einmal, Sie wäre nicht die gleiche, aber wie diese werden analysiert, die durch eine EF-Abfrage Anbieter Sie sollten wirklich nicht immer Nebenwirkungen haben.

Dank David B für die Bereitstellung einen link zu in diesem Zusammenhang Frage die eine ReplaceVisitor Umsetzung. Wir können diesen ReplaceVisitor zu gehen durch die gesamte Struktur eines Ausdrucks und ersetzen eines Ausdrucks durch einen anderen. Die Umsetzung dieser Typ ist:

class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}

Und jetzt können wir schreiben unsere richtige Combine Methode:

public static Expression<Func<T1, T3>> Combine<T1, T2, T3>(
    this Expression<Func<T1, T2>> first,
    Expression<Func<T2, T3>> second)
{
    var param = Expression.Parameter(typeof(T1), "param");

    var newFirst = new ReplaceVisitor(first.Parameters.First(), param)
        .Visit(first.Body);
    var newSecond = new ReplaceVisitor(second.Parameters.First(), newFirst)
        .Visit(second.Body);

    return Expression.Lambda<Func<T1, T3>>(newSecond, param);
}

und ein einfacher Testfall, um einfach nur zeigen, was Los ist:

Expression<Func<MyObject, string>> fn1 = x => x.PossibleSubPath.MyStringProperty;
Expression<Func<string, bool>> fn2 = x => x.Contains("some literal");

var composite = fn1.Combine(fn2);

Console.WriteLine(composite);

Dem heraus gedruckt wird:

param => param.PossibleSubPath.MyStringProperty.Enthält("some literal")

Das ist genau das, was wir wollen; eine Abfrage-Anbieter wissen, wie zu analysieren, dass so etwas wie.