Holen Sie sich den Namen der Eigenschaft in einem Lambda-Ausdruck in .NET 3.5

Question

Ich habe ein Problem, das mich seit einiger Zeit gequält hat und ich kann die Antwort nicht finden.

Ich muss den Namen der Eigenschaft erhalten, die in einem Lambda-Ausdruck referenziert wird. Ich würde den Lambda-Ausdruck einer Methode bereitstellen, die eine Zeichenfolge zurückgeben würde. wenn ich zum Beispiel haben:

x => x.WeirdPropertyName 

dann endet das Verfahren zurück:

"WeirdPropertyName" 

Ich habe gelesen, dass es mit Ausdruck Bäume getan werden kann, aber die Antwort hat mich ausgewichen.

Vielen Dank für jede Hilfe

Answer 1

Hier gehen Sie:

string GetPropertyName<T>(Expression<Func<T>> property) 
{ 
    var propertyInfo = (property.Body as MemberExpression).Member as PropertyInfo; 
    if (propertyInfo == null) 
    { 
     throw new ArgumentException("The lambda expression 'property' should point to a valid Property"); 
    } 
    return propertyInfo.Name; 
} 

Answer 2

Der einzige Weg, ich kenne den String Name einer Eigenschaft des Erhaltens ist durch Reflexion.

Answer 3

Ich habe here eine ziemlich umfassende Antwort.

Zusätzlich zum Umgang mit Ausdrücken wie x => x.WeirdPropertyName kann es auch mit "erweiterten" Ausdrücken wie x => x.WeirdMember.WeirdPropertyName umgehen.

Hier ist der Code aus dieser Antwort:

// code adjusted to prevent horizontal overflow 
static string GetFullPropertyName<T, TProperty> 
(Expression<Func<T, TProperty>> exp) 
{ 
    MemberExpression memberExp; 
    if (!TryFindMemberExpression(exp.Body, out memberExp)) 
     return string.Empty; 

    var memberNames = new Stack<string>(); 
    do 
    { 
     memberNames.Push(memberExp.Member.Name); 
    } 
    while (TryFindMemberExpression(memberExp.Expression, out memberExp)); 

    return string.Join(".", memberNames.ToArray()); 
} 

// code adjusted to prevent horizontal overflow 
private static bool TryFindMemberExpression 
(Expression exp, out MemberExpression memberExp) 
{ 
    memberExp = exp as MemberExpression; 
    if (memberExp != null) 
    { 
     // heyo! that was easy enough 
     return true; 
    } 

    // if the compiler created an automatic conversion, 
    // it'll look something like... 
    // obj => Convert(obj.Property) [e.g., int -> object] 
    // OR: 
    // obj => ConvertChecked(obj.Property) [e.g., int -> long] 
    // ...which are the cases checked in IsConversion 
    if (IsConversion(exp) && exp is UnaryExpression) 
    { 
     memberExp = ((UnaryExpression)exp).Operand as MemberExpression; 
     if (memberExp != null) 
     { 
      return true; 
     } 
    } 

    return false; 
} 

private static bool IsConversion(Expression exp) 
{ 
    return (
     exp.NodeType == ExpressionType.Convert || 
     exp.NodeType == ExpressionType.ConvertChecked 
    ); 
}