c# - new - Cómo Func<DomainObject, object> devuelve el nombre del objeto como cadena

func string c#

Question

Esta pregunta ya tiene una respuesta aquí:

• Recuperando el nombre de la propiedad de la expresión lambda 18 respuestas
• Obtener el nombre de la cadena de la propiedad usando reflection 7 answers

Tengo un método estático como este:

    public static string MyMethod(Func<Student, object> func)
    {            
        return ??? ;
    }

y lo uso de la siguiente manera:

    var s1 = MyMethod(student => student.ID); // Return "ID" ???
    var s2 = MyMethod(student => student.Age); // Return "Age" ???
    var s3 = MyMethod(student => student.Name); // Return "Name" ???

¿Cómo escribir el método que devuelve los siguientes resultados?

• s1: "ID"
• s2: "Edad"
• s3: "Nombre"

* devuelve el nombre de cada propiedad después de => como cadena

Answer 1

De otra pregunta SO , esto puede ser lo que estás buscando:

public static string GetPropertyName<T>(Expression<Func<T>> propertyExpression)
{
    return (propertyExpression.Body as MemberExpression).Member.Name;
}

Para usarlo, escribirías algo como esto:

var propertyName = GetPropertyName(
    () => myObject.AProperty); // returns "AProperty"

Answer 2

La firma debe incluir el árbol de expresión en lugar de func para poder inspeccionarlo. Afortunadamente, sus invocaciones no cambian ya que el compilador creará expresiones de sus lambdas.

Esta versión es probablemente la más corta, no implica la recursión, pero funciona solo para el acceso a la propiedad simple lambdas.

public static string MyFunc( Expression<Func<Student, object>> Property )
{
     if ( Property != null && Property.Body != null )
         if ( Property.Body.NodeType == ExpressionType.MemberAccess )
         {
             MemberExpression memberExpression = 
                (MemberExpression)Property.Body;

             if ( !string.IsNullOrEmpty( memberExpression.Member.Name ) )
                 return memberExpression.Member.Name;

         }

     return string.Empty;
 }

Answer 3

Puede cambiar la firma de su método de

  public static string MyMethod(Func<Student, object> func)

cambiarlo a

  public static string MyMethod(Expression<Func<Student, object>> func) {
     return GetMemeberName(func)
  } 

  public static string GetMemberName(Expression expression)
    {            
        if (expression is LambdaExpression)
        {
            var lambdaExpression = (LambdaExpression)expression;
            return GetMemberName(lambdaExpression.Body);                              
        }

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