C# Language
nom de l'opérateur

Introduction

Syntaxe

• nameof (expression)

Utilisation de base: Impression d'un nom de variable

L'opérateur nameof vous permet d'obtenir le nom d'une variable, d'un type ou d'un membre sous forme de chaîne sans le coder comme un littéral. L'opération est évaluée au moment de la compilation, ce qui signifie que vous pouvez renommer, en utilisant la fonctionnalité de renommage de l'EDI, un identifiant référencé et que la chaîne de nom sera mise à jour avec lui.

var myString = "String Contents";
Console.WriteLine(nameof(myString));

Serait sortie

myString

car le nom de la variable est "myString". Refactoriser le nom de la variable changerait la chaîne.

Si elle est appelée sur un type de référence, l'opérateur nameof renvoie le nom de la référence en cours, pas le nom ou le nom du type de l'objet sous-jacent. Par exemple:

string greeting = "Hello!";
Object mailMessageBody = greeting;

Console.WriteLine(nameof(greeting)); // Returns "greeting"
Console.WriteLine(nameof(mailMessageBody)); // Returns "mailMessageBody", NOT "greeting"!

Impression d'un nom de paramètre

Fragment

public void DoSomething(int paramValue)
{
    Console.WriteLine(nameof(paramValue));
}

...

int myValue = 10;
DoSomething(myValue);

Sortie de console

paramValue

Événement Raising PropertyChanged

Fragment

public class Person : INotifyPropertyChanged
{
    private string _address;

    public event PropertyChangedEventHandler PropertyChanged;

    private void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public string Address
    {
        get { return _address; }
        set
        {
            if (_address == value)
            {
                return;
            }

            _address = value;
            OnPropertyChanged(nameof(Address));
        }
    }
}

...

var person = new Person();
person.PropertyChanged += (s,e) => Console.WriteLine(e.PropertyName);

person.Address = "123 Fake Street";

Sortie de console

Adresse

Gestion des événements PropertyChanged

Fragment

public class BugReport : INotifyPropertyChanged
{
    public string Title { ... }
    public BugStatus Status { ... }
}

...

private void BugReport_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    var bugReport = (BugReport)sender;

    switch (e.PropertyName)
    {
        case nameof(bugReport.Title):
            Console.WriteLine("{0} changed to {1}", e.PropertyName, bugReport.Title);
            break;

        case nameof(bugReport.Status):
            Console.WriteLine("{0} changed to {1}", e.PropertyName, bugReport.Status);
            break;
    }
}

...

var report = new BugReport();
report.PropertyChanged += BugReport_PropertyChanged;

report.Title = "Everything is on fire and broken";
report.Status = BugStatus.ShowStopper;

Sortie de console

Titre changé en Tout est en feu et cassé

Statut changé en ShowStopper

Appliqué à un paramètre de type générique

Fragment

public class SomeClass<TItem>
{
    public void PrintTypeName()
    {
        Console.WriteLine(nameof(TItem));
    }
}

...

var myClass = new SomeClass<int>();
myClass.PrintTypeName();

Console.WriteLine(nameof(SomeClass<int>));

Sortie de console

TItem

SomeClass

Appliqué aux identificateurs qualifiés

Fragment

Console.WriteLine(nameof(CompanyNamespace.MyNamespace));
Console.WriteLine(nameof(MyClass));
Console.WriteLine(nameof(MyClass.MyNestedClass));
Console.WriteLine(nameof(MyNamespace.MyClass.MyNestedClass.MyStaticProperty));

Sortie de console

MyNamespace

Ma classe

MyNestedClass

MyStaticProperty

Vérification des arguments et clauses de garde

Préférer

public class Order
{
    public OrderLine AddOrderLine(OrderLine orderLine)
    {
        if (orderLine == null) throw new ArgumentNullException(nameof(orderLine));
        ...
    }
}

Plus de

public class Order
{
    public OrderLine AddOrderLine(OrderLine orderLine)
    {
        if (orderLine == null) throw new ArgumentNullException("orderLine");
        ...
    }
}    

L'utilisation de la fonction nameof facilite la refactorisation des paramètres de méthode.

Liens d'action MVC fortement typés

Au lieu de l'habituellement tapé librement:

@Html.ActionLink("Log in", "UserController", "LogIn")

Vous pouvez maintenant créer des liens d'action fortement typés:

@Html.ActionLink("Log in", @typeof(UserController), @nameof(UserController.LogIn))

Maintenant, si vous souhaitez modifier votre code et renommer la méthode UserController.LogIn en UserController.SignIn , vous n'avez pas à vous soucier de rechercher toutes les occurrences de chaînes. Le compilateur fera le travail.