.net - new - nameof error c#

¿Por qué el nombre de sólo devuelve el apellido?

Question

nameof (order.User.Age) devuelve solo "Age" en lugar de "order.User.Age"

¿Cuál es la razón para hacerlo de forma más restringida? Si solo queremos apellido podemos hacer algo como

public static GetLastName(this string x) { 
    return string.Split(x, ''.'').Last();
}
nameof(order.User.Age).GetLastName()

Y con un solo operador podríamos obtener tanto "Edad" como "orden.Usuario.Age". Pero con la implementación actual solo podemos obtener "Age".

¿Hay alguna lógica detrás de esta decisión?

Edición: por ejemplo, tal comportamiento es necesario para el enlace MVC

Html.TextBox(nameof(order.User.Age))

Answer 1

Algunos de los propósitos importantes de usar nameof es obtener el último "nombre" en la expresión.

Por ejemplo, el parámetro nameof al lanzar ArgumentNullException :

void Method(string parameter)
{
     if (parameter == null) throw new ArgumentNullException(nameof(parameter));
}

Enlaces de acción de MVC

<%= Html.ActionLink("Sign up",
    @typeof(UserController),
    @nameof(UserController.SignUp))
%>

INotifyPropertyChanged

int p {
    get { return this._p; }
    set { this._p = value; PropertyChanged(this, new PropertyChangedEventArgs(nameof(this.p)); }
}

Más información: https://roslyn.codeplex.com/discussions/570551

Answer 2

Echa un vistazo a este método tomado de:

https://github.com/okhosting/OKHOSTING.Data/blob/master/src/PCL/OKHOSTING.Data/Validation/MemberExpression.cs

public static string GetMemberString(System.Linq.Expressions.Expression<Func<T, object>> member)
    {
        if (member == null)
        {
            throw new ArgumentNullException("member");
        }

        var propertyRefExpr = member.Body;
        var memberExpr = propertyRefExpr as System.Linq.Expressions.MemberExpression;

        if (memberExpr == null)
        {
            var unaryExpr = propertyRefExpr as System.Linq.Expressions.UnaryExpression;

            if (unaryExpr != null && unaryExpr.NodeType == System.Linq.Expressions.ExpressionType.Convert)
            {
                memberExpr = unaryExpr.Operand as System.Linq.Expressions.MemberExpression;

                if(memberExpr != null)
                {
                    return memberExpr.Member.Name;
                }
            }
        }
        else
        {
            //gets something line "m.Field1.Field2.Field3", from here we just remove the prefix "m."
            string body = member.Body.ToString();
            return body.Substring(body.IndexOf(''.'') + 1);
        }

        throw new ArgumentException("No property reference expression was found.", "member");
    }

Answer 3

Porque es exactamente para lo que se ha inventado. Como puede leer en discusiones ya vinculadas , aquí está usando el nameof operador como nameof(member-access) , del formulario EI<A1…AK> , que devolverá:

Todos estos casos se resuelven utilizando las reglas para la búsqueda simple de nombres $ 7.6.2 o el acceso de miembros $ 7.6.4. Si logran vincularse, deben vincularse a uno de:

• Un método-grupo. Esto produce un error "Para especificar el nombre de un método, debe proporcionar sus argumentos".
• Una variable, valor, parámetro, constante, miembro de enumeración, propiedad-acceso, campo, evento, tipo-parámetro, espacio de nombres o tipo. En este caso, el resultado del operador nameof es simplemente "I" , que generalmente es el nombre del símbolo al que está vinculado el argumento. Hay algunas advertencias ...

Entonces, en este caso, por definición, debe evaluar todas las expresiones antes de todos los puntos, paso a paso, y luego evaluar la última para obtener su Name :

order.User.Age --> User.Age --> Age

Answer 4

Tenga en cuenta que si necesita / desea el nombre "completo", puede hacer esto:

$"{nameof(order)}.{nameof(User)}.{nameof(Age)}".GetLastName();

siempre y cuando todos estos nombres estén en el alcance actual .

Obviamente, en este caso, en realidad no es tan útil (los nombres no estarán dentro del alcance de la llamada de Razor), pero podría ser si fuera necesario, por ejemplo, el nombre completo de un tipo calificado para el espacio de nombres para una llamada a Type.GetType() o algo así.

Si los nombres no están dentro del alcance, aún podría hacer algo más torpe:

$"{nameof(order)}.{nameof(order.User)}.{nameof(order.User.Age)}".GetLastName();

- aunque es probable que al menos uno de ellos esté dentro del alcance (a menos que User.Age sea ​​una propiedad estática).