Récupère le nom de la propriété de chaîne à partir de l'expression

Je suis en train d'écrire un typage fort helper
ce qui serait quelque chose comme ceci:

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

pour l'instant j'ai ceci:

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

Quelqu'un sait comment faire cela ?

source d'informationauteur Omu

  1. 24
    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;
    }
}

    Vous serait alors de l'appeler avec:

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

    Encore un autre code.

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

    Utilisation ExpressionHelper classe.
    Func est délégué, l'Expression est de générer Expressionarborescence au moment de la compilation.
    De l'Expression.Compiler() renvoient un délégué, mais Func n'obtenez pas Expressionarborescence au moment de l'exécution.

  3. 8

    Actuellement à l'aide de cette classe quand j'ai besoin de cette fonction à l'extérieur de projet web où System.Web.Mvc de référence ne devrait pas exister:

    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));
    }
  }
}

    Bonne chose à ce sujet est - il ne pas perdre de points quand plus profond que juste un niveau.

  4. 0

    un peu tard, mais je mets en ligne une solution simple c'est de travailler pour moi .Net 4. Il a de la manipulation pour les types de valeur sur la ligne 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;
    }