Expression > comment puis-je obtenir le nom de TValue?

.net c# expression-trees

Question

//ModelFor(person =>person.Name);
public void ModelFor<TModel, TValue>(
    Expression<Func<TModel, TValue>> expression)
{
    //Result should be "Name"
    string nameOfTValue = ????;     
}

Réponse acceptée

EDIT : Après votre édition, je pense que vous voulez le nom du membre impliqué dans l'expression, en supposant bien sûr que l'expression est un membre-expression en premier lieu.

((MemberExpression)expression.Body).Member.Name

Pour être plus robuste, vous pouvez faire:

var memberEx = expression.Body as MemberExpression;

if (memberEx == null)
     throw new ArgumentException("Body not a member-expression.");

string name = memberEx.Member.Name;

(Plus pertinent):

Pour obtenir un System.Type qui représente le type de l'argument de type TValue , vous pouvez utiliser l'opérateur typeof .

Vous voulez probablement:

typeof(TValue).Name

Mais considérez également les propriétés FullName et AssemblyQualifiedName , le cas échéant.

Cela n'a vraiment rien à voir avec les arbres d'expression; vous pouvez utiliser cette technique pour obtenir le type d'un argument de type pour toute méthode générique.


Réponse populaire

@Ani: Je ne pense pas que c'est correct, je pense qu'il veut le nom du paramètre dans l'expression du type TValue

Si cela est vrai ... cela ne fonctionne que sur 1 niveau mais peut être utile quand même:

var nameOfTValue = ((MemberExpression)expression.Body).Member.Name; 

Voici une mise en œuvre plus intelligente qui devrait pouvoir traiter à plusieurs niveaux:

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

Usage:

var fieldName=PropertyName.For<Customer>(x=>x.Address.Region);
//fieldName==Address.Region

Une autre astuce, cela peut être combiné avec réflexion:

public static T Set<T,TProp>(this T o,
   Expression<Func<T,TProp>> field,TProp value){
  var fn=((MemberExpression)field.Body).Member.Name;
  o.GetType().GetProperty(fn).SetValue(o,value,null);
  return o;
}

Permet de définir directement les propriétés avec facilité, peut être utile pour les montages de test:

var customer=new Customer("firstName","lastName");
customer.Set(x=>x.Name, "different firstName");


Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi