Quel est le but de nameof?

La version 6.0 a une nouvelle fonctionnalité nameof, mais je ne comprends pas le but de celle-ci, car elle prend simplement le nom de la variable et le change en chaîne lors de la compilation.

Je pensais que cela pourrait avoir un but lors de l'utilisation, <T>mais lorsque j'essaye, nameof(T)cela m'imprime juste un Tau lieu du type utilisé.

Une idée sur le but?

Qu'en est-il des cas où vous souhaitez réutiliser le nom d'une propriété, par exemple lors du lancement d'une exception basée sur un nom de propriété ou de la gestion d'un PropertyChangedévénement. Il existe de nombreux cas où vous voudriez avoir le nom de la propriété.

Prenez cet exemple:

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

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

Dans le premier cas, SomePropertyle changement de nom modifiera également le nom de la propriété ou interrompra la compilation. Le dernier cas ne fonctionne pas.

C'est un moyen très utile de garder votre code compilé et sans bug (sorte de).

(Un très bel article d'Eric Lippert pourquoi infoofne l'a pas fait, alors qu'il l'a nameoffait)

C'est vraiment utile pour ArgumentExceptionet 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 inputparamè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 nameofest 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 INotifyPropertyChangedet 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....");
}

Un autre cas d'utilisation où la nameoffonctionnalité de C # 6.0 devient pratique - Considérez une bibliothèque comme Dapper qui facilite les récupérations de bases de données. Bien qu'il s'agisse d'une excellente bibliothèque, vous devez coder en dur les noms de propriété / champ dans la requête. Cela signifie que si vous décidez de renommer votre propriété / champ, il y a de fortes chances que vous oubliez de mettre à jour la requête pour utiliser de nouveaux noms de champ. Avec l'interpolation et les nameoffonctionnalités de chaîne , le code devient beaucoup plus facile à maintenir et à sécuriser.

De l'exemple donné dans le lien

sans nom

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

avec nameof

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

Votre question exprime déjà le but. Vous devez voir que cela peut être utile pour la journalisation ou le lancement d'exceptions.

par exemple.

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

c'est bien, si je change le nom de la variable, le code se cassera à la place ou retournera une exception avec un message incorrect .

Bien entendu, les utilisations ne se limitent pas à cette simple situation. Vous pouvez utiliser nameofchaque fois qu'il serait utile de coder le nom d'une variable ou d'une propriété.

Les utilisations sont multiples lorsque l'on considère diverses situations de reliure et de réflexion. C'est un excellent moyen d'apporter ce qui était des erreurs d'exécution pour compiler le temps.

Le cas d'utilisation le plus courant auquel je peux penser est lorsque vous travaillez avec l' INotifyPropertyChangedinterface. (Fondamentalement, tout ce qui concerne WPF et les liaisons utilise cette interface)

Jetez un œil à cet exemple:

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

Comme vous pouvez le voir à l'ancienne, nous devons passer une chaîne pour indiquer quelle propriété a changé. Avec nameofnous pouvons utiliser directement le nom de la propriété. Cela pourrait ne pas sembler être un gros problème. Mais imaginez ce qui se passe lorsque quelqu'un change le nom de la propriété Foo. Lorsque vous utilisez une chaîne, la liaison cessera de fonctionner, mais le compilateur ne vous avertira pas. Lorsque vous utilisez nameof, vous obtenez une erreur de compilation qu'il n'y a pas de propriété / argument avec le nom Foo.

Notez que certains frameworks utilisent de la magie de réflexion pour obtenir le nom de la propriété, mais maintenant nous avons nameof ce n'est plus nécessaire .

L'utilisation la plus courante sera dans la validation des entrées, comme

//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));
}

En premier cas, si vous refactoring la méthode changer par le nom de paramètre, vous oublierez probablement changer que dans le ArgumentNullException . Avec nameof, vous n'avez pas à vous en soucier.

Voir aussi: nameof (référence C # et Visual Basic)

Le projet ASP.NET Core MVC utilise nameofdans AccountController.cset ManageController.csavec la RedirectToActionméthode pour référencer une action dans le contrôleur.

Exemple:

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

Cela se traduit par:

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

et prend prend l'utilisateur à l'action «Index» dans le contrôleur «Accueil», à savoir /Home/Index.

Comme d'autres l'ont déjà souligné, l' nameofopérateur insère le nom que l'élément a été donné dans le code source.

Je voudrais ajouter que c'est une très bonne idée en termes de refactoring car cela rend cette refactoring de chaîne sûre. Auparavant, j'utilisais une méthode statique qui utilisait la réflexion dans le même but, mais qui a un impact sur les performances d'exécution. L' nameofopérateur n'a aucun impact sur les performances d'exécution; il fait son travail au moment de la compilation. Si vous regardez le MSILcode, vous trouverez la chaîne intégrée. Voir la méthode suivante et son code désassemblé.

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

Cependant, cela peut être un inconvénient si vous prévoyez d'obscurcir votre logiciel. Après l'obscurcissement, la chaîne incorporée peut ne plus correspondre au nom de l'élément. Les mécanismes qui s'appuient sur ce texte se briseront. Des exemples pour cela, y compris, mais sans s'y limiter, sont: Reflection, NotifyPropertyChanged ...

La détermination du nom pendant l'exécution coûte quelques performances, mais est sans danger pour l'obscurcissement. Si l'obscurcissement n'est ni requis ni prévu, je recommanderais d'utiliser l' nameofopérateur.

Considérez que vous utilisez une variable dans votre code et que vous devez obtenir le nom de la variable et disons l'imprimer, vous devriez avoir à utiliser

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

Et si quelqu'un refactorise le code et utilise un autre nom pour "myVar", il devra surveiller la valeur de la chaîne dans votre code et la modifier en conséquence.

Au lieu de cela, si vous aviez

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

Cela aiderait à refactoriser automatiquement!

L'article MSDN répertorie le routage MVC (l'exemple qui a vraiment cliqué sur le concept pour moi) parmi plusieurs autres. Le paragraphe de description (formaté) se lit comme suit:

• Lorsque vous signalez des erreurs de code,
• raccordement de liaisons modèle-vue-contrôleur (MVC),
• le tir des biens a changé des événements, etc.,

vous souhaitez souvent capturer le nom de chaîne d'une méthode . L'utilisation de nameof permet de garder votre code valide lors du changement de nom des définitions.

Avant, vous deviez utiliser des littéraux de chaîne pour faire référence aux définitions, ce qui est fragile lorsque vous renommez des éléments de code car les outils ne savent pas vérifier ces littéraux de chaîne.

Les réponses acceptées / les mieux notées donnent déjà plusieurs excellents exemples concrets.

Le but de la nameof opérateur est de fournir le nom source des artefacts.

Habituellement, le nom de la source est le même que le nom des métadonnées:

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

Mais ce n'est pas toujours le cas:

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

Ou:

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

Une utilisation que je lui ai donnée est pour nommer les ressources:

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

Le fait est que, dans ce cas, je n'avais même pas besoin des propriétés générées pour accéder aux ressources, mais maintenant j'ai un temps de compilation pour vérifier que les ressources existent.

L'une des utilisations de nameofmot-clé est de définir Bindingpar programme wpf .

pour définir, Bindingvous devez définir Pathavec une chaîne et avec un nameofmot clé, il est possible d'utiliser l'option Refactor.

Par exemple, si vous avez IsEnableune propriété de dépendance dans votre UserControlet que vous souhaitez la lier à IsEnablecertaines CheckBoxde vos UserControl, vous pouvez utiliser ces deux codes:

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

et

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

Il est évident que le premier code ne peut pas être refactorisé mais le second ...

Auparavant, nous utilisions quelque chose comme ça:

// 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)
{
    ...
}

Raison - compiler la sécurité du temps. Personne ne peut renommer silencieusement une propriété et rompre la logique du code. Maintenant, nous pouvons utiliser nameof ().

Il présente un avantage lorsque vous utilisez ASP.Net MVC. Lorsque vous utilisez l'aide HTML pour créer un contrôle dans la vue, il utilise des noms de propriété dans l'attribution de nom de l'entrée html:

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

Cela fait quelque chose comme ça:

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

Alors maintenant, si vous devez valider votre propriété dans la méthode Validate, vous pouvez le faire:

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

Si vous renommez votre propriété à l'aide d'outils de refactoring, votre validation ne sera pas interrompue.

Un autre cas d'utilisation de nameofconsiste à vérifier les pages à onglets, au lieu de vérifier l'index, vous pouvez vérifier la Namepropriété des pages à onglets comme suit:

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

Moins salissant :)

Je trouve que cela nameofaugmente la lisibilité des instructions SQL très longues et complexes dans mes applications. Il fait ressortir les variables de cet océan de chaînes et élimine votre tâche de déterminer où les variables sont utilisées dans vos instructions 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 },
    }
}