命名的目的是什么?

6.0版获得了nameof的新特性，但我不能理解它的目的，因为它只是接受变量名并在编译时将其更改为字符串。

我认为它在使用<T>时可能有一些用途，但当我尝试nameof(T)时，它只是打印出一个T而不是使用的类型。

知道目的吗?

211958 次浏览
小开

它对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....");
}
小开

你的问题已经表达了目的。您必须看到，这对于记录日志或抛出异常可能很有用。

例如:

public void DoStuff(object input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
}

这很好。如果我更改了变量的名称，代码将中断，而不是返回带有错误消息的异常。

当然，用途并不局限于这种简单的情况。只要对变量或属性的名称编码有用，就可以使用nameof。

当您考虑各种绑定和反射情况时，其用途是多方面的。这是一种将运行时错误带到编译时的极好方法。

小开
最佳答案

如果你想重用一个属性的名称，例如根据属性名抛出异常，或处理PropertyChanged事件，该怎么办?在许多情况下，您都希望拥有属性的名称。

举个例子:

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


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

在第一种情况下，如果不同时更改属性定义和nameof(SomeProperty)表达式，则重命名SomeProperty将导致编译错误。在第二种情况下，重命名SomeOtherProperty或修改"SomeOtherProperty"字符串将导致无声地破坏运行时行为，在构建时没有错误或警告。

这是一种非常有用的方法，可以保持代码的编译和(在某种程度上)没有错误。

(A Eric Lippert写的很好的文章为什么infoof没有成功，而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));
}

在第一种情况下，如果你重构改变票面价值参数名称的方法，你可能会忘记在ArgumentNullException. c中改变它。对于nameof，你不必担心这个。

参见:名称(c#和Visual Basic参考)

小开

假设您需要在代码中打印一个变量的名称。如果你这样写:

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

然后如果有人重构代码并使用另一个名称myVar，他/她将不得不在你的代码中寻找字符串值并相应地更改它。

相反，如果你这样写:

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

这将有助于自动重构!

小开

我能想到的最常见的用例是使用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 this了。

小开

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))]

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

小开

正如其他人已经指出的那样，nameof操作符确实插入了源代码中给出的元素名称。

我想补充一点，这在重构方面是一个非常好的想法，因为它使得字符串重构是安全的。以前，我使用了一个静态方法，它利用反射来达到同样的目的，但这对运行时性能有影响。nameof操作符对运行时性能没有影响;它在编译时完成它的工作。如果你看一下MSIL代码，你会发现字符串嵌入。请参阅下面的方法及其反汇编代码。

static void Main(string[] args)
{
Console.WriteLine(nameof(args));
Console.WriteLine("regular text");
}


// striped nops from the listing
IL_0001 ldstr args
IL_0006 call System.Void System.Console::WriteLine(System.String)
IL_000C ldstr regular text
IL_0011 call System.Void System.Console::WriteLine(System.String)
IL_0017 ret

然而，如果您打算让软件变得模糊，这可能是一个缺点。经过混淆处理后，嵌入的字符串可能不再匹配元素的名称。依赖于此文本的机制将会崩溃。例如，包括但不限于:Reflection, NotifyPropertyChanged…

在运行时确定名称会损失一些性能，但对于混淆是安全的。如果混淆既不需要也不计划，我建议使用nameof操作符。

小开

MSDN文章 .在其他几个例子中列出了MVC路由(对我来说真正点击概念的例子)。(格式化的)描述段落如下:

  • 当报告代码中的错误时，
  • 连接模型-视图-控制器(MVC)链接，
  • 触发属性改变事件，等等，

你经常想 捕获方法的字符串名称。使用nameof可以帮助保存代码 重命名定义时有效。

之前你必须使用字符串字面量 在重命名代码元素时引用定义，它很脆 因为工具不知道检查这些字符串文字。

公认的/评分最高的答案已经给出了几个很好的具体例子。

小开

ASP。NET Core MVC项目在AccountController.cs和ManageController.cs中使用nameof和RedirectToAction方法来引用控制器中的动作。

例子:

return RedirectToAction(nameof(HomeController.Index), "Home");

这句话的意思是:

return RedirectToAction("Index", "Home");

和takes将用户带到'Home'控制器中的'Index'动作，即/Home/Index。

小开

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

要设置Binding，你必须用字符串设置Path，并且使用nameof关键字，可以使用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);

很明显，第一个代码不能重构，但第二个代码……

小开

之前我们使用的是这样的东西:

// 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()。

小开

c# 6.0的nameof特性变得方便的另一个用例 -考虑像衣冠楚楚的这样的库，它使DB检索更容易。虽然这是一个很棒的库，但您需要在查询中硬编码属性/字段名。这意味着如果你决定重命名你的属性/字段，你很有可能会忘记更新查询来使用新的字段名。有了字符串插值和nameof特性，代码变得更容易维护和类型安全。

从链接中给出的例子

没有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});
小开

它在使用ASP时具有一定的优势。净MVC。当你使用HTML helper在视图中构建一些控件时，它使用HTML输入的name属性中的属性名:

@Html.TextBoxFor(m => m.CanBeRenamed)

它是这样的:

<input type="text" name="CanBeRenamed" />

所以现在，如果你需要在validate方法中验证你的属性，你可以这样做:

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) {
if (IsNotValid(CanBeRenamed)) {
yield return new ValidationResult(
$"Property {nameof(CanBeRenamed)} is not valid",
new [] { $"{nameof(CanBeRenamed)}" })
}
}

如果你使用重构工具重命名你的属性，你的验证不会被破坏。

小开

nameof的另一个用例是检查标签页，你可以检查标签页的Name属性，如下所示:

if(tabControl.SelectedTab.Name == nameof(tabSettings))
{
// Do something
}

不那么乱:)

小开

我发现nameof增加了我的应用程序中非常长和复杂的SQL语句的可读性。它使变量从字符串的海洋中脱颖而出，并消除了确定变量在SQL语句中的使用位置的工作。

public bool IsFooAFoo(string foo, string bar)
{
var aVeryLongAndComplexQuery = $@"SELECT yada, yada
-- long query in here
WHERE fooColumn = @{nameof(foo)}
AND barColumn = @{nameof(bar)}
-- long query here";




SqlParameter[] parameters = {
new SqlParameter(nameof(foo), SqlDBType.VarChar, 10){ Value = foo },
new SqlParameter(nameof(bar), SqlDBType.VarChar, 10){ Value = bar },
}
}
小开

nameof的作用是重构。例如，当你在代码中其他地方通过nameof引用一个类的名字时，你会得到一个编译错误哪一个才是你想要的。如果你没有使用nameof，只有一个普通的字符串作为引用，你必须全文搜索类的名称才能更改它。那是一种痛苦。有了nameof，您就可以轻松地在IDE中自动构建和获取所有需要更改的用例。


提交答案