C#: Pobieranie nazw właściwości w łańcuchu z wyrażenia lambda

Question

Zajmuję się tworzeniem interfejsu API, który używa wyrażeń lambda do określania właściwości. Używam tego słynnego fragmentu kodu podobnego do tego (to jest uproszczony i niepełny, żeby wyjaśnić, co mam na myśli):

public void Foo<T, P>(Expression<Func<T, P>> action) 
{ 
    var expression = (MemberExpression)action.Body; 
    string propertyName = expression.Member.Name; 
    // ... 
} 

Aby nazwać tak:

Foo((String x) => x.Length); 

teraz chciałbym, aby określić ścieżkę nieruchomości przez łańcuchowym nazwy właściwości, na przykład:

Foo((MyClass x) => x.Name.Length); 

Foo powinien móc podzielić ścieżkę do jego nazwy własności ("Name" i "Length"). Czy jest jakiś sposób na zrobienie tego przy rozsądnym wysiłku?

---

Jest somehow similar looking question, ale myślę, że starają się łączyć wyrażenia lambda tam.

Another question również zajmuje się nazwami zagnieżdżonych właściwości, ale tak naprawdę nie rozumiem, o czym mówią.

Answer 1

Coś takiego?

public void Foo<T, P>(Expression<Func<T, P>> expr) 
{ 
    MemberExpression me; 
    switch (expr.Body.NodeType) 
    { 
     case ExpressionType.Convert: 
     case ExpressionType.ConvertChecked: 
      var ue = expr.Body as UnaryExpression; 
      me = ((ue != null) ? ue.Operand : null) as MemberExpression; 
      break; 
     default: 
      me = expr.Body as MemberExpression; 
      break; 
    } 

    while (me != null) 
    { 
     string propertyName = me.Member.Name; 
     Type propertyType = me.Type; 

     Console.WriteLine(propertyName + ": " + propertyType); 

     me = me.Expression as MemberExpression; 
    } 
} 

Answer 2

Stare pytanie, wiem ... ale jeśli to tylko nazwy trzeba, jeszcze prostszy sposób to zrobić to:

expr.ToString().Split('.').Skip(1) 

EDIT:

public class A 
{ 
    public B Property { get; set; } 
} 

public class B 
{ 
    public C field; 
} 

[Fact] 
public void FactMethodName() 
{ 
    var exp = (Expression<Func<A, object>>) (x => x.Property.field); 
    foreach (var part in exp.ToString().Split('.').Skip(1)) 
     Console.WriteLine(part); 

    // Output: 
    // Property 
    // field 
} 

Answer 3

Grałem trochę z ExpressionVisitor:

public static class PropertyPath<TSource> 
{ 
    public static IReadOnlyList<MemberInfo> Get<TResult>(Expression<Func<TSource, TResult>> expression) 
    { 
     var visitor = new PropertyVisitor(); 
     visitor.Visit(expression.Body); 
     visitor.Path.Reverse(); 
     return visitor.Path; 
    } 

    private class PropertyVisitor : ExpressionVisitor 
    { 
     internal readonly List<MemberInfo> Path = new List<MemberInfo>(); 

     protected override Expression VisitMember(MemberExpression node) 
     { 
      if (!(node.Member is PropertyInfo)) 
      { 
       throw new ArgumentException("The path can only contain properties", nameof(node)); 
      } 

      this.Path.Add(node.Member); 
      return base.VisitMember(node); 
     } 
    } 
} 

Zastosowanie:

var path = string.Join(".", PropertyPath<string>.Get(x => x.Length).Select(p => p.Name));