Proposal: Consider adding $ syntactic sugar for nameof.

[TyreeJackson]

Nuisance

We've been using nameof extensively on our projects. This has turned out to be a very handy feature, but in our multitude of assert statements in our tests, having to type nameof over and over is getting cumbersome.

Proposal

Consider a $ or some other prefix character that can be placed before any variable, type or member to produce their name.

For example (samples borrowed from https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/nameof):

Console.WriteLine($System.Collections.Generic);  // output: Generic
Console.WriteLine($List<int>));  // output: List
Console.WriteLine($List<int>.Count);  // output: Count
Console.WriteLine($List<int>.Add);  // output: Add

var numbers = new List<int> { 1, 2, 3 };
Console.WriteLine($numbers);  // output: numbers
Console.WriteLine($numbers.Count);  // output: Count
Console.WriteLine($numbers.Add);  // output: Add

var @new = 5;
Console.WriteLine($@new);  // output: new 

public string Name
{
    get => name;
    set => name = value ?? throw new ArgumentNullException($value, $"{$Name} cannot be null");
}

EDIT (6-6-2020):

@dzmitry-lahoda made an alternate suggestion in the comments that works better. Instead of the $ originally suggested, surrounding the variable, type or member with backticks would work nicely. So for example:

Console.WriteLine(`System.Collections.Generic`);  // output: Generic
Console.WriteLine(`List<int>`));  // output: List
Console.WriteLine(`List<int>.Count`);  // output: Count
Console.WriteLine(`List<int>.Add`);  // output: Add

var numbers = new List<int> { 1, 2, 3 };
Console.WriteLine(`numbers`);  // output: numbers
Console.WriteLine(`numbers.Count`);  // output: Count
Console.WriteLine(`numbers.Add`);  // output: Add

var @new = 5;
Console.WriteLine(`@new`);  // output: new 

public string Name
{
    get => name;
    set => name = value ?? throw new ArgumentNullException($value, $"{`Name`} cannot be null");
}

[theunrepentantgeek]

having to type nameof over and over is getting cumbersome.

Code gets written once (or maybe twice 😃) and read dozens of times. I'd suggest trading a few characters of typing for impaired readability is a poor tradeoff.

[dzmitry-lahoda]

nameof(...) impairs readability 😆
Usage of symbol like

`

, so instead of nameof(FooBar) I could type

`FooBar`

, could help.

[theunrepentantgeek]

The keyword nameof() tells the reader exactly what it does. Cryptic use of symbols does not, it has to be learned and recalled when found.

Check into the formal research on readability - it turns out that symbols are not faster to read nor to process for comprehension. For experienced readers, they come out about equal, but for learners, symbols are much slower.

[TyreeJackson]

nameof(...) impairs readability 😆
Usage of symbol like

`

, so instead of nameof(FooBar) I could type

`FooBar`

, could help.

Actually, I like this idea better than the $ prefix. Backticks would work great. What we really want to see is the name, but also ensure that if the member spelling changes that the reference to it changes as well. And quotes, double quotes and backticks are already common place, so it should not be a large hurdle to learn. In fact it's already common in MarkDown.

[CyrusNajmabadi]

Actually, I like this idea better than the $ prefix. Backticks would work great

I'm strongly opposed to this. It would be using a very suitable syntax for something that is already trivially supported today. I would not want to use ` for this as i would prefer that be saved for some much more valuable feature that isn't possible already.