Konstruieren LambdaExpression für die nested-Eigenschaft von string

Ich versuche zu erstellen, die einen lambda-Ausdruck für eine nested-Eigenschaft zur Laufzeit aus dem Namen der Eigenschaft. Grundsätzlich bin ich versucht zu erstellen, die den lambda-Ausdruck angegeben:

var expression = CreateExpression<Foo, object>(foo => foo.myBar.name);

private static Expression CreateExpression<TEntity, TReturn>(Expression<Func<TEntity, TReturn>> expression)
{
    return (expression as Expression);
}

Mit den Klassen:

class Foo
{
    public Bar myBar { get; set; }
}
class Bar
{
    public string name { get; set; }
}

Jedoch alle ich bin der Typ der Foo und der string "myBar.name"

Wenn es eine normale Eigenschaft wie einfach nur brauchen, um den Wert "myBar" dann könnte ich die folgenden:

private static LambdaExpression GetPropertyAccessLambda(Type type, string propertyName)
{
    ParameterExpression odataItParameter = Expression.Parameter(type, "$it");
    MemberExpression propertyAccess = Expression.Property(odataItParameter, propertyName);
    return Expression.Lambda(propertyAccess, odataItParameter);
}

Aber dieser code funktioniert nicht bei verschachtelten Eigenschaften und ich bin nicht sicher, wie Sie Sie zum erstellen der LambdaExpression, um die Arbeit der foo.myBar.name.

Ich denke es wird so etwas wie dieses:

GetExpression(Expression.Call(GetExpression(Foo, "myBar"), "name"))

Aber ich kann nicht scheinen, um herauszufinden, wie alles funktioniert, oder ob es einen besseren Weg, dies zu tun, die zur Zeit ausführen.

InformationsquelleAutor Seph | 2013-04-25
  1. 91

    Meinst du:

    static LambdaExpression CreateExpression(Type type, string propertyName) {
    var param = Expression.Parameter(type, "x");
    Expression body = param;
    foreach (var member in propertyName.Split('.')) {
        body = Expression.PropertyOrField(body, member);
    }
    return Expression.Lambda(body, param);
}

    Beispiel:

    class Foo {
    public Bar myBar { get; set; }
}
class Bar {
    public string name { get; set; }
}
static void Main() {
    var expression = CreateExpression(typeof(Foo), "myBar.name");
    //x => x.myBar.name
}

    ?

    • Yep, das ist genau das was ich gesucht hatte, mein Fehler war zu denken, dass ich brauchte, berufen sich auf die Körper-Ausdruck (mit Call), bevor man die nested-Eigenschaft.
    • Super Antwort! +1 für Klarheit
    • Fantastische Antwort von Marc Gravell, die es gelöst für mich. Als bonus, resharper Tat dies, um Ihren code: var Parameter = Expression.Parameter(type, "x"); Expression Körper = propertyName.Split('.').Aggregat<string, Ausdruck>(param, Ausdruck.PropertyOrField); return Expression.Lambda(Körper, param);
    • Es ist wirklich cool. Marc, gibt es jede Möglichkeit zu nutzen, die das gleiche Verhalten mit verschachtelten Liste? Ich meine class Foo {public List<Bar> myBar { get; set; }}
    InformationsquelleAutor Marc Gravell
Schreibe einen Kommentar