Obtener cadena de nombre de la propiedad de la expresión

Question

Estoy intentando escribir un ayudante inflexible que sería algo como esto:

Html.Lookup(x => x.FooId); 

por ahora tengo esto:

public static MvcHtmlString Lookup<T,TReturn>(this HtmlHelper<T> html, Func<T, TReturn> expression) 
     { 
      // get string "FooId" here 
     } 

nadie sabe cómo para obtener esto?

Answer 1

public static class ExpressionsExtractor 
{ 
    public static string Lookup<T, TProp>(this HtmlHelper<T> html, Expression<Func<T, TProp>> expression) 
    { 
     var memberExpression = expression.Body as MemberExpression; 

     if (memberExpression == null) 
      return null; 

     return memberExpression.Member.Name; 
    } 
} 

A continuación, llamarlo con:

var propName = Html.Lookup(x => x.FooId); 

Answer 2

Sin embargo, otro código.

public MvcHtmlString Lookup<T, TReturn>(this HtmlHelper<T> html, Expression<Func<T, TReturn>> expression) 
{ 
    return MvcHtmlString.Create(ExpressionHelper.GetExpressionText(expression)); 
} 

Usar la clase ExpressionHelper. Func es delegado, Expression genera ExpressionTree en tiempo de compilación. Expression.Compile() devuelve delegado, pero Func no obtiene ExpressionTree en tiempo de ejecución.

Answer 3

Actualmente el uso de esta clase cuando necesito esta funcionalidad fuera del proyecto web donde System.Web.Mvc referencia no debería existir:

namespace Interreg.Domain{ 
    using System; 
    using System.Linq.Expressions; 
    public class PropertyName{ 
    public static string For<T>(
     Expression<Func<T,object>> expression){ 
     var body=expression.Body; 
     return GetMemberName(body); 
    } 
    public static string For(
     Expression<Func<object>> expression){ 
     var body=expression.Body; 
     return GetMemberName(body); 
    } 
    public static string GetMemberName(
     Expression expression){ 
     if(expression is MemberExpression){ 
     var memberExpression=(MemberExpression)expression; 
     if(memberExpression.Expression.NodeType== 
      ExpressionType.MemberAccess) 
      return GetMemberName(memberExpression.Expression)+"."+memberExpression.Member.Name; 
     return memberExpression.Member.Name; 
     } 
     if(expression is UnaryExpression){ 
     var unaryExpression=(UnaryExpression)expression; 
     if(unaryExpression.NodeType!=ExpressionType.Convert) 
      throw new Exception(string.Format("Cannot interpret member from {0}",expression)); 
     return GetMemberName(unaryExpression.Operand); 
     } 
     throw new Exception(string.Format("Could not determine member from {0}",expression)); 
    } 
    } 
} 

Lo bueno de este es - no pierde puntos cuando se va más profundo que sólo una nivel.

Answer 4

un poco tarde, pero estoy publicando una solución simple que funciona para mí en .Net 4. Se ha manipulación de los tipos de valor en la línea 4

public PropertyInfo GetPropertyInfo<TSource>(Expression<Func<TSource, object>> propertyLambda) { 
     var member = propertyLambda.Body as MemberExpression; 
     if (member == null) {// value types return Convert(x.property) which can't be cast to MemberExpression 
      var expression = propertyLambda.Body as UnaryExpression; 
      member = expression.Operand as MemberExpression; 
     } 
     return member.Member as PropertyInfo; 
    }