最重要的是nameof不会影响性能!

 nameof有什么用?主要用解决 类成员名做参数替代成员们的字符串做参数,如下:



using  System;
namespace csharp6
{
internal class Program
{
private static void Main(string[] args)
{
if (args==null)
{
throw new ArgumentNullException("args");//旧的写法 变量名的字符串做参数

//throw new ArgumentNullException(nameOf(args));//新的写法 避免了args变量名更改后,忘记更改字符串"args",因为字符串编译器是不错提示错误的

} } } }


 这样非常有利于后期项目维护,比如我们在使用MVC开发时候,后端返回到某个视图,我们平时喜欢写字符串的形式,如果项目越来越大,后期突然哪个控制器或者动作不用了,使用字符串的形式维护起来就非常麻烦,用nameof就可以很好的解决,最重要的是不会影响性能!

 nameof 运算符

 nameof是C#6新增的一个关键字运算符,主要作用是方便获取类型、成员和变量的简单字符串名称(非完全限定名),意义在于避免我们在代码中写下固定的一些字符串,这些固定的字符串在后续维护代码时是一个很繁琐的事情。比如上面的代码改写后:



using  System;
namespace csharp6
{
internal class Program
{
private static void Main(string[] args)
{
if (args==null)
{
throw new ArgumentNullException(nameof(args));
}
}
}
}


我们把固定的 "args" 替换成等价的 nameof(args) 。按照惯例,贴出来两种方式的代码的IL。

"args"方式的IL代码



.method private hidebysig static void  Main(string[] args) cil managed
{
.entrypoint
// Code size 22 (0x16)
.maxstack 2
.locals init ([0] bool V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldnull
IL_0003: ceq
IL_0005: stloc.0
IL_0006: ldloc.0
IL_0007: brfalse.s IL_0015
IL_0009: nop
IL_000a: ldstr "args"
IL_000f: newobj instance void [mscorlib]System.ArgumentNullException::.ctor(string)
IL_0014: throw
IL_0015: ret
} // end of method Program::Main


nameof(args)方式的IL代码:



.method private hidebysig static void  Main(string[] args) cil managed
{
.entrypoint
// Code size 22 (0x16)
.maxstack 2
.locals init ([0] bool V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldnull
IL_0003: ceq
IL_0005: stloc.0
IL_0006: ldloc.0
IL_0007: brfalse.s IL_0015
IL_0009: nop
IL_000a: ldstr "args"
IL_000f: newobj instance void [mscorlib]System.ArgumentNullException::.ctor(string)
IL_0014: throw
IL_0015: ret
} // end of method Program::Main


一样一样的,我是没看出来有任何的差异,,,so,这个运算符也是一个编译器层面提供的语法糖,编译后就没有nameof的影子了。

3. nameof 注意事项

nameof可以用于获取具名表达式的当前名字简单字符串表示(非完全限定名)。注意当前名字这个限定,比如下面这个例子,你觉得会输出什么结果?



using static System.Console;
using CC = System.ConsoleColor;

namespace csharp6
{
internal class Program
{
private static void Main()
{
WriteLine(nameof(CC));//CC
WriteLine(nameof(System.ConsoleColor));//ConsoleColor
}
}
}


第一个语句输出"CC",因为它是当前的名字,虽然是指向System.ConsoleColor枚举的别名,但是由于CC是当前的名字,那么nameof运算符的结果就是"CC"。

第二个语句输出了"ConsoleColor",因为它是System.ConsoleColor的简单字符串表示,而非取得它的完全限定名,如果想取得"System.ConsoleColor",那么请使用 typeof(System.ConsoleColor).FullName 。再比如微软给的例子: nameof(person.Address.ZipCode) ,结果是"ZipCode"。

以上内容来自:

​ javascript:void(0)​

以前我们使用的是这样的:

// Some form.
SetFieldReadOnly( () => Entity.UserName );
...
// Base form.
private void SetFieldReadOnly(Expression<Func<object>> property)
{
var propName = GetPropNameFromExpr(property);
SetFieldsReadOnly(propName);
}

private void SetFieldReadOnly(string propertyName)
{
...
}


原因-编译时间安全。 没有人可以默默地重命名属性并破坏代码逻辑。 现在我们可以使用nameof()了。



 



如果要重用属性名称,例如在基于属性名称引发异常或处理 ​​PropertyChanged​​ 事件时,该怎么办? 在很多情况下,您都希望使用属性名称。

举个例子:

switch (e.PropertyName)
{
case nameof(SomeProperty):
{ break; }

// opposed to
case "SomeOtherProperty":
{ break; }
}


在第一种情况下,重命名 ​​SomeProperty​​ 也将更改属性的名称,否则将中断编译。 最后一种情况没有。

这是保持代码编译和消除错误(排序)的一种非常有用的方法。

( ​​ Eric Lippert的一篇非常不错的文章, ​​ 为什么 ​​infoof​​ 没能做到,而 ​​nameof​​ 却做到了)



 



对于 ​​ArgumentException​​ 及其派生类确实非常有用:

public string DoSomething(string input) 
{
if(input == null)
{
throw new ArgumentNullException(nameof(input));
}
...


现在,如果有人重构 ​​input​​ 参数的名称,该异常也将保持最新状态。

在某些以前必须使用反射来获取属性或参数名称的地方,它也很有用。

在您的示例中, ​​nameof(T)​​ 获取类型参数的名称-这也可能有用:

throw new ArgumentException(nameof(T), $"Type {typeof(T)} does not support this method.");


​nameof​​ 另一种用法是用于枚举-通常,如果您想要使用 ​​.ToString()​​ 的枚举的字符串名称:

enum MyEnum { ... FooBar = 7 ... }

Console.WriteLine(MyEnum.FooBar.ToString());

> "FooBar"


由于.Net保留枚举值(即 ​​7​​ )并在运行时查找名称,因此这实际上相对较慢。

而是使用 ​​nameof​​ :

Console.WriteLine(nameof(MyEnum.FooBar))

> "FooBar"


现在,.Net在编译时用字符串替换枚举名称。

还有另一个用途是用于 ​​INotifyPropertyChanged​​ 和日志记录-在两种情况下,您都希望将要调用的成员的名称传递给另一个方法:

// Property with notify of change
public int Foo
{
get { return this.foo; }
set
{
this.foo = value;
PropertyChanged(this, new PropertyChangedEventArgs(nameof(this.Foo));
}
}


要么...

// Write a log, audit or trace for the method called
void DoSomething(... params ...)
{
Log(nameof(DoSomething), "Message....");
}


 



我能想到的最常见的用例是使用 ​​INotifyPropertyChanged​​ 接口时。 (基本上,与WPF和绑定有关的所有内容都使用此接口)

看一下这个例子:

public class Model : INotifyPropertyChanged
{
// From the INotifyPropertyChanged interface
public event PropertyChangedEventHandler PropertyChanged;

private string foo;
public String Foo
{
get { return this.foo; }
set
{
this.foo = value;
// Old code:
PropertyChanged(this, new PropertyChangedEventArgs("Foo"));

// New Code:
PropertyChanged(this, new PropertyChangedEventArgs(nameof(Foo)));
}
}
}


如您所见,我们必须传递一个字符串以指示哪个属性已更改。 使用 ​​nameof​​ 我们可以直接使用属性的名称。 这似乎没什么大不了的。 但是想像一下当有人更改属性 ​​Foo​​ 的名称时会发生什么。 使用字符串时,绑定将停止工作,但编译器不会警告您。 使用nameof时,会出现一个编译器错误,即没有名称为 ​​Foo​​ 属性/参数。

请注意,某些框架使用一些反射魔术来获取属性的名称,但是现在我们有了nameof,它不再是必需的



 



最常见的用法是在输入验证中,例如

//Currently
void Foo(string par) {
if (par == null) throw new ArgumentNullException("par");
}

//C# 6 nameof
void Foo(string par) {
if (par == null) throw new ArgumentNullException(nameof(par));
}


在第一种情况下,如果重构更改 par 参数名称的方法,则可能会忘记在 ArgumentNullException中 进行更改。 使用 nameof, 您不必担心。

另请参见: ​​ nameof(C#和Visual Basic参考) ​



 



考虑到您在代码中使用了变量,并且需要获取变量的名称并可以说将其打印出来,因此您必须使用

int myVar = 10;
print("myVar" + " value is " + myVar.toString());


然后如果有人重构代码并为“ myVar”使用另一个名称,则他/她将必须注意代码中的字符串值并相应地对其进行处理。

相反,如果您有

print(nameof(myVar) + " value is " + myVar.toString());


这将有助于自动重构!



 



​nameof​​ 关键字的用法之一是用于以 编程方式 在wpf中设置 ​​Binding​​ 。

要设置 ​​Binding​​ 您必须使用字符串和 ​​nameof​​ 关键字设置 ​​Path​​ ,可以使用Refactor选项。

例如,如果您在 ​​UserControl​​ 具有 ​​IsEnable​​ 依赖项属性,并且要将其绑定到 ​​UserControl​​ 中某些 ​​CheckBox​​ ​​IsEnable​​ ,则可以使用以下两个代码:

CheckBox chk = new CheckBox();
Binding bnd = new Binding ("IsEnable") { Source = this };
chk.SetBinding(IsEnabledProperty, bnd);


CheckBox chk = new CheckBox();
Binding bnd = new Binding (nameof (IsEnable)) { Source = this };
chk.SetBinding(IsEnabledProperty, bnd);


很明显,第一个代码无法重构,而第二个代码可以重构。



 



​nameof​​ 运算符的目的是提供工件的源名称。

通常,源名称与元数据名称相同:

public void M(string p)
{
if (p == null)
{
throw new ArgumentNullException(nameof(p));
}
...
}

public int P
{
get
{
return p;
}
set
{
p = value;
NotifyPropertyChanged(nameof(P));
}
}


但这并非总是如此:

using i = System.Int32;
...
Console.WriteLine(nameof(i)); // prints "i"


要么:

public static string Extension<T>(this T t)
{
return nameof(T); returns "T"
}


我一直给它的一种用途是命名资源:

[Display(
ResourceType = typeof(Resources),
Name = nameof(Resources.Title_Name),
ShortName = nameof(Resources.Title_ShortName),
Description = nameof(Resources.Title_Description),
Prompt = nameof(Resources.Title_Prompt))]


事实是,在这种情况下,我什至不需要生成的属性来访问资源,但是现在有了编译时检查资源是否存在。



 



C#6.0的 nameof 功能变得很方便的另一个用例 -考虑像 ​​ Dapper ​​ 这样的库,它使DB检索更加容易。 尽管这是一个很棒的库,但是您需要在查询中对属性/字段名称进行硬编码。 这意味着如果您决定重命名属性/字段,则很可能会忘记更新查询以使用新的字段名。 使用字符串插值和 ​​nameof​​ 功能,代码变得更加易于维护和类型安全。

从链接中给出的示例

没有名字

var dog = connection.Query<Dog>("select Age = @Age, Id = @Id", new { Age = (int?)null, Id = guid });


与nameof

var dog = connection.Query<Dog>($"select {nameof(Dog.Age)} = @Age, {nameof(Dog.Id)} = @Id", new { Age = (int?)null, Id = guid });

以上内容来自: https://code-examples.net/zh-CN/q/1e3a41c


编程是个人爱好