C# Language
Name des Betreibers

Einführung

Syntax

• nameof (Ausdruck)

Grundlegende Verwendung: Drucken eines Variablennamens

Mit nameof Operator nameof können Sie den Namen einer Variablen, eines Typs oder eines Members in Zeichenfolgenform nameof , ohne sie als Literal hart zu codieren. Die Operation wird zur Kompilierzeit ausgewertet. Das bedeutet, dass Sie mit der Umbenennungsfunktion einer IDE einen referenzierten Bezeichner umbenennen können und die Namenszeichenfolge damit aktualisiert wird.

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

Würde ausgeben

myString

weil der Name der Variablen "myString" ist. Durch Umgestaltung des Variablennamens wird die Zeichenfolge geändert.

Bei Aufruf für einen Referenztyp gibt der Name des Operators den Namen der aktuellen Referenz zurück, nicht den Namen oder den nameof des zugrunde liegenden Objekts. Zum Beispiel:

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

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

Einen Parameternamen drucken

Ausschnitt

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

...

int myValue = 10;
DoSomething(myValue);

Konsolenausgabe

paramValue

PropertyChanged-Ereignis auslösen

Ausschnitt

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";

Konsolenausgabe

Adresse

Behandlung von PropertyChanged-Ereignissen

Ausschnitt

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;

Konsolenausgabe

Titel geändert in Alles brennt und ist kaputt

Status wurde in ShowStopper geändert

Wird auf einen generischen Typparameter angewendet

Ausschnitt

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

...

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

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

Konsolenausgabe

TItem

SomeClass

Auf qualifizierte Bezeichner angewendet

Ausschnitt

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

Konsolenausgabe

MeinNamensraum

Meine Klasse

MyNestedClass

MyStaticProperty

Argumentprüfung und Schutzklauseln

Bevorzugen

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

Über

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

Die Verwendung der Funktion nameof erleichtert das nameof Methodenparametern.

Stark typisierte MVC-Aktionslinks

Anstelle der üblichen locker getippt:

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

Sie können jetzt stark typisierte Aktionslinks erstellen:

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

Wenn Sie nun Ihren Code umgestalten und die UserController.LogIn Methode in UserController.SignIn umbenennen möchten, müssen Sie sich nicht um die Suche nach allen Vorkommen von Zeichenfolgen kümmern. Der Compiler erledigt die Arbeit.