C#: obteniendo los nombres de las propiedades en una cadena de la expresión lambda

Question

Estoy desarrollando una API que usa expresiones lambda para especificar propiedades. Estoy usando esta famosa pieza de código similar a ésta (esto se simplifica e incompleta, sólo para dejar claro lo que estoy hablando):

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

que se llamará así:

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

Ahora me gustaría especificar una ruta de propiedad por el encadenamiento de los nombres de propiedades, así:

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

Foo debe ser capaz de dividir la ruta en sus nombres de propiedad ("Name" y "Length"). ¿Hay alguna manera de hacer esto con un esfuerzo razonable?

---

Hay una somehow similar looking question, pero creo que están tratando de combinar las expresiones lambda allí.

Another question también se trata de nombres de propiedades anidadas, pero realmente no entiendo de qué están hablando.

Answer 1

¿Algo como esto?

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

vieja pregunta, lo sé ... pero si es sólo los nombres que necesita, de una manera aún más sencilla de hacerlo es:

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

Jugué un poco con 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); 
     } 
    } 
} 

Uso:

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