Блог

nameof(order.User.Age) возвращает только Age вместо order.User.Age

В чем причина делать это более ограниченным способом? Если нам нужна только фамилия, мы могли бы сделать что-то вроде

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

nameof(order.User.Age).GetLastName()
  

И с помощью одного оператора мы могли бы получить оба, Age и order.User.Age . Но с текущей реализацией мы можем получить только Age . Есть ли какая-то логика в этом решении? Например, такое поведение необходимо для привязки MVC

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

Обратите внимание, что если вам нужно / нужно «полное» имя, вы могли бы сделать это:

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

пока все эти имена находятся в текущей области.

Очевидно, что в данном случае это не совсем так полезно (имена не будут находиться в области видимости при вызове Razor), но это может быть, если вам нужно, например, полное имя пространства имен определенного типа для вызова Type.GetType() или что-то в этом роде.

Если имена не входят в область видимости, вы все равно можете сделать несколько более неуклюжий:

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

— хотя есть вероятность, что хотя бы один из них должен быть в области видимости (если User.Age это не статическое свойство).

Потому что это именно то, для чего это было изобретено. Как вы можете прочитать в уже связанных обсуждениях, здесь вы используете nameof оператор as nameof(member-access) формы E.I<A1…AK> , который вернет:

Все эти случаи разрешаются с использованием правил простого поиска имен $ 7.6.2 или доступа к участникам $ 7.6.4. Если им удается выполнить привязку, они должны привязаться к одному из:

• Метод-группа. Это приводит к ошибке «Чтобы указать имя метода, вы должны предоставить его аргументы».
• Переменная, значение, параметр, константа, элемент перечисления, доступ к свойству, поле, событие, параметр типа, пространство имен или тип. В этом случае результатом оператора nameof является просто «I», который обычно является именем символа, с которым связан аргумент. Есть несколько предостережений…

Итак, в этом случае он, по его определению, должен вычислять все выражения перед всеми точками, шаг за шагом, и после этого вычислять последнее, чтобы получить его Name :

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

У меня была та же проблема, и я реализовал класс, который действует как замена nameof() ключевого слова, чтобы получить полное имя предоставляемого выражения. Это очень вдохновлено ответом OK HOSTING. Все готово и готово к использованию:

 public static class NameOf<TSource>
{
    #region Public Methods

    public static string Full(Expression<Func<TSource, object>> expression)
    {
        var memberExpression = expression.Body as MemberExpression;
        if (memberExpression == null)
        {
            var unaryExpression = expression.Body as UnaryExpression;
            if (unaryExpression != null amp;amp; unaryExpression.NodeType == ExpressionType.Convert)
                memberExpression = unaryExpression.Operand as MemberExpression;
        }

        var result = memberExpression.ToString();
        result = result.Substring(result.IndexOf('.')   1);

        return resu<
    }

    public static string Full(string sourceFieldName, Expression<Func<TSource, object>> expression)
    {
        var result = Full(expression);
        result = string.IsNullOrEmpty(sourceFieldName) ? result : sourceFieldName   "."   resu<
        return resu<
    }

    #endregion
}
  

Его использование в вашем коде будет выглядеть так:

 class SpeciesFamily
{
    public string Name { get; set; }
}

class Species
{
    public SpeciesFamily Family { get; set; }
    public string Name { get; set; }
}

class Cat
{
    public Species Species { get; set; }
}

// Will return a string containing "Species.Family.Name".
var fullName = NameOf<Cat>.Full(c => c.Species.Family.Name);

// Will return a string containing "cat.Species.Name".
var fullNameWithPrefix = NameOf<Cat>.Full("cat", c => c.Species.Name);
  

Взгляните на этот метод, взятый из:

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

Некоторые из важных целей использования nameof — получить последнее «имя» в выражении.

Например, параметр nameof при выбрасывании ArgumentNullException :

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

Ссылки на действия 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)); }
}
  

Дополнительная информация: https://roslyn.codeplex.com/discussions/570551