C# Language
namn på operatör

Introduktion

Syntax

• nameof (uttryck)

Grundläggande användning: Skriva ut ett variabelt namn

nameof operatören låter dig få namnet på en variabel, typ eller medlem i strängform utan att hårdkoda det som en bokstavlig. Åtgärden utvärderas vid kompileringstid, vilket innebär att du kan byta namn på med hjälp av en IDE-namn, en referensidentifierare och namnsträngen kommer att uppdateras med den.

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

Skulle producera

Mystring

eftersom variabelns namn är "myString". Om man omarbetar variabelns namn ändras strängen.

Om man nameof en referenstyp nameof operatörens namn namnet på den aktuella referensen, inte namnet eller typnamnet på det underliggande objektet. Till exempel:

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

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

Skriva ut ett parameternamn

Fragment

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

...

int myValue = 10;
DoSomething(myValue);

Konsolutgång

paramValue

Att höja PropertyChanged-händelse

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

Konsolutgång

Adress

Hantering av fastigheter förändrade händelser

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;

Konsolutgång

Titeln ändrats till Allt är i brand och trasig

Status ändrades till ShowStopper

Tillämpas på en parameter av generisk typ

Fragment

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

...

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

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

Konsolutgång

TItem

SomeClass

Tillämpas på kvalificerade identifierare

Fragment

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

Konsolutgång

MyNamespace

Min klass

MyNestedClass

MyStaticProperty

Argumentkontroll och skyddsklausuler

Föredra

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

Över

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

Användning av nameof funktionen gör det lättare att refactor-metodparametrar.

Starkt typade MVC-actionlänkar

Istället för det vanliga löst skrivna:

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

Du kan nu göra actionlänkar som är starkt skrivna:

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

Om du nu vill refaktorera din kod och byta namn på UserController.LogIn metoden till UserController.SignIn , behöver du inte oroa dig för att söka efter alla stränghändelser. Kompilatorn gör jobbet.