C'est vraiment utile pour ArgumentException
et ses dérivés:
public string DoSomething(string input)
{
if(input == null)
{
throw new ArgumentNullException(nameof(input));
}
...
Maintenant, si quelqu'un refactorise le nom du input
paramètre, l'exception sera également mise à jour.
Il est également utile dans certains endroits où auparavant la réflexion devait être utilisée pour obtenir les noms des propriétés ou des paramètres.
Dans votre exemple, nameof(T)
obtient le nom du paramètre type - cela peut également être utile:
throw new ArgumentException(nameof(T), $"Type {typeof(T)} does not support this method.");
Une autre utilisation de nameof
est pour les énumérations - généralement si vous voulez le nom de chaîne d'une énumération que vous utilisez .ToString()
:
enum MyEnum { ... FooBar = 7 ... }
Console.WriteLine(MyEnum.FooBar.ToString());
> "FooBar"
C'est en fait relativement lent car .Net détient la valeur enum (c'est-à-dire 7
) et trouve le nom au moment de l'exécution.
Utilisez plutôt nameof
:
Console.WriteLine(nameof(MyEnum.FooBar))
> "FooBar"
Désormais .Net remplace le nom de l'énumération par une chaîne au moment de la compilation.
Encore une autre utilisation est pour des choses comme INotifyPropertyChanged
et la journalisation - dans les deux cas, vous voulez que le nom du membre que vous appelez soit transmis à une autre méthode:
// Property with notify of change
public int Foo
{
get { return this.foo; }
set
{
this.foo = value;
PropertyChanged(this, new PropertyChangedEventArgs(nameof(this.Foo));
}
}
Ou...
// Write a log, audit or trace for the method called
void DoSomething(... params ...)
{
Log(nameof(DoSomething), "Message....");
}