Jaki jest cel nameof?

Wersja 6.0 ma nową funkcję nameof, ale nie rozumiem jej celu, ponieważ po prostu pobiera nazwę zmiennej i zmienia ją na ciąg znaków podczas kompilacji.

Myślałem, że może mieć jakiś cel podczas używania, <T>ale kiedy próbuję, po nameof(T)prostu drukuje mi Tzamiast używanego typu.

Masz pomysł na cel?

Co z przypadkami, w których chcesz ponownie użyć nazwy właściwości, na przykład podczas zgłaszania wyjątku na podstawie nazwy właściwości lub obsługi PropertyChangedzdarzenia. Istnieje wiele przypadków, w których chciałbyś mieć nazwę nieruchomości.

Weź ten przykład:

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

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

W pierwszym przypadku zmiana nazwy SomeProperty zmieni również nazwę właściwości lub przerwie kompilację. Ostatni przypadek nie.

Jest to bardzo przydatny sposób na utrzymanie kompilacji kodu i brak błędów (sortowanie).

( Bardzo fajny artykuł Erica Lipperta, dlaczego tego infoofnie zrobił, a nameofzrobił)

Jest naprawdę przydatny ArgumentExceptioni jego pochodne:

public string DoSomething(string input) 
{
    if(input == null) 
    {
        throw new ArgumentNullException(nameof(input));
    }
    ...

Teraz, jeśli ktoś inputzmieni nazwę parametru, wyjątek również będzie aktualizowany.

Jest także przydatny w niektórych miejscach, w których wcześniej trzeba było zastosować odbicie, aby uzyskać nazwy właściwości lub parametrów.

W twoim przykładzie nameof(T)dostaje nazwę parametru typu - może to być również przydatne:

throw new ArgumentException(nameof(T), $"Type {typeof(T)} does not support this method.");

Innym zastosowaniem nameofjest wyliczanie - zwykle jeśli chcesz, aby nazwa ciągu wyliczenia była używana .ToString():

enum MyEnum { ... FooBar = 7 ... }

Console.WriteLine(MyEnum.FooBar.ToString());

> "FooBar"

Jest to faktycznie stosunkowo wolne, ponieważ .Net przechowuje wartość wyliczania (tj. 7) I znajduje nazwę w czasie wykonywania.

Zamiast tego użyj nameof:

Console.WriteLine(nameof(MyEnum.FooBar))

> "FooBar"

Teraz .Net zastępuje nazwę wyliczenia ciągiem w czasie kompilacji.

Jeszcze inne zastosowanie to takie jak INotifyPropertyChangedlogowanie i logowanie - w obu przypadkach chcesz, aby nazwa członka, do którego dzwonisz, została przekazana do innej metody:

// Property with notify of change
public int Foo
{
    get { return this.foo; }
    set
    {
        this.foo = value;
        PropertyChanged(this, new PropertyChangedEventArgs(nameof(this.Foo));
    }
}

Lub...

// Write a log, audit or trace for the method called
void DoSomething(... params ...)
{
    Log(nameof(DoSomething), "Message....");
}

Kolejny przypadek użycia, w którym nameofprzydatna jest funkcja C # 6.0 - Rozważmy bibliotekę taką jak Dapper, która znacznie ułatwia pobieranie DB. Chociaż jest to świetna biblioteka, musisz wpisać twarde nazwy właściwości / pól w zapytaniu. Oznacza to, że jeśli zdecydujesz się zmienić nazwę swojej nieruchomości / pola, istnieje duże prawdopodobieństwo, że zapomnisz zaktualizować zapytanie w celu użycia nowych nazw pól. Dzięki interpolacji ciągów i nameoffunkcjom kod staje się znacznie łatwiejszy w utrzymaniu i bezpieczny w użyciu.

Z przykładu podanego w linku

bez nazwy

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

o nazwie

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

Twoje pytanie wyraża już cel. Musisz zobaczyć, że może to być przydatne do rejestrowania lub zgłaszania wyjątków.

na przykład.

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

to dobrze, jeśli zmienię nazwę zmiennej, kod zostanie uszkodzony lub zwróci wyjątek z niepoprawnym komunikatem .

Oczywiście zastosowania nie ograniczają się do tej prostej sytuacji. Możesz użyć, nameofilekroć przydatne byłoby zakodowanie nazwy zmiennej lub właściwości.

Zastosowania są różnorodne, gdy weźmie się pod uwagę różne sytuacje wiązania i refleksji. Jest to doskonały sposób na skompilowanie błędów, które były błędami w czasie wykonywania.

Najczęstszym przypadkiem użycia, jaki mogę wymyślić, jest praca z INotifyPropertyChangedinterfejsem. (Zasadniczo wszystko związane z WPF i powiązaniami korzysta z tego interfejsu)

Spójrz na ten przykład:

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

Jak widać po staremu, musimy przekazać ciąg znaków wskazujący, która właściwość uległa zmianie. Dzięki nameofmożemy użyć nazwy nieruchomości bezpośrednio. To nie może wydawać się wielkim problemem. Ale wyobraź sobie, co się dzieje, gdy ktoś zmienia nazwę nieruchomości Foo. Gdy użyjesz łańcucha, wiązanie przestanie działać, ale kompilator cię nie ostrzeże. Podczas używania nameof pojawia się błąd kompilatora, że ​​nie ma właściwości / argumentu o nazwie Foo.

Zauważ, że niektóre frameworki używają magii odbicia, aby uzyskać nazwę właściwości, ale teraz mamy nazwę tego nie jest już konieczne .

Najczęstszym zastosowaniem będzie sprawdzanie poprawności danych wejściowych, np

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

W pierwszym przypadku, jeśli byłaby sposób zmieniający PAR nazwę parametru, prawdopodobnie będziesz zapomnij zmienić w ArgumentNullException . Z imieniem nie musisz się tym martwić.

Zobacz także: nameof (C # i Visual Basic Reference)

Projekt ASP.NET Core MVC wykorzystuje nameofwAccountController.cs i ManageController.csze RedirectToActionsposobu odwołać akcję w kontrolerze.

Przykład:

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

To przekłada się na:

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

i przenosi użytkownika do akcji „Indeks” w kontrolerze „Dom”, tj /Home/Index.

Jak już zauważyli inni, nameof operator wstawia nazwę nadaną elementowi w kodzie źródłowym.

Chciałbym dodać, że jest to naprawdę dobry pomysł w zakresie refaktoryzacji, ponieważ sprawia, że ​​refaktoryzacja łańcucha jest bezpieczna. Wcześniej korzystałem z metody statycznej, która korzystała z odbicia w tym samym celu, ale ma to wpływ na wydajność środowiska wykonawczego. nameofOperator ma wpływ na działanie środowiska wykonawczego; wykonuje swoją pracę w czasie kompilacji. Jeśli spojrzysz na MSILkod, znajdziesz ciąg osadzony. Zobacz następującą metodę i jej zdemontowany kod.

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

Może to jednak stanowić wadę, jeśli planujesz zaciemnić oprogramowanie. Po zaciemnieniu osadzony ciąg może już nie pasować do nazwy elementu. Mechanizmy oparte na tym tekście się zepsują. Przykładami tego, w tym między innymi: Reflection, NotifyPropertyChanged ...

Określenie nazwy w czasie wykonywania kosztuje pewną wydajność, ale jest bezpieczne dla zaciemnienia. Jeśli zaciemnianie nie jest wymagane ani planowane, zaleciłbym użycie nameofoperatora.

Weź pod uwagę, że używasz zmiennej w kodzie i musisz uzyskać nazwę zmiennej, i powiedzmy, wydrukuj ją, powinieneś użyć

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

A jeśli ktoś zmieni kod i użyje innej nazwy dla „myVar”, będzie musiał obserwować wartość ciągu w twoim kodzie i odpowiednio ją chenge.

Zamiast tego, gdybyś miał

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

Pomoże to automatycznie refaktoryzować!

Artykuł MSDN wymienia routing MVC (przykład, który naprawdę kliknął moją koncepcję) wśród kilku innych. (Sformatowany) akapit opisu brzmi:

• Zgłaszając błędy w kodzie,
• podłączanie linków model-view-controller (MVC),
• uruchamianie zdarzeń zmieniających właściwość itp.,

często chcesz uchwycić nazwę ciągu metody . Użycie nameof pomaga zachować poprawność kodu podczas zmiany nazw definicji.

Wcześniej trzeba było używać literałów ciągowych w celu odniesienia się do definicji, co jest kruche przy zmianie nazw elementów kodu, ponieważ narzędzia nie wiedzą, jak je sprawdzić.

Akceptowane / najwyżej oceniane odpowiedzi podają już kilka doskonałych konkretnych przykładów.

Cel nameof operatora jest podanie nazwy źródła artefaktów.

Zwykle nazwa źródła jest taka sama jak nazwa metadanych:

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

Ale nie zawsze tak może być:

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

Lub:

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

Jednym z zastosowań, które mu nadałem, jest nazywanie zasobów:

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

Faktem jest, że w tym przypadku nawet nie potrzebowałem wygenerowanych właściwości, aby uzyskać dostęp do zasobów, ale teraz sprawdzam, czy zasoby istnieją.

Jednym ze sposobów użycia nameofsłowa kluczowego jest programowe ustawienie Bindingw wpf .

aby ustawić Bindingmusisz ustawić Pathciąg, a nameofsłowem kluczowym można użyć opcji Refaktoryzuj.

Na przykład, jeśli masz IsEnablewłaściwość zależności UserControli chcesz ją powiązać IsEnablez niektórymi CheckBoxz ciebie UserControl, możesz użyć tych dwóch kodów:

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

i

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

To oczywiste, że pierwszy kod nie może zostać zmieniony, ale ten zabezpieczający ...

Wcześniej używaliśmy czegoś takiego:

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

Powód - skompiluj bezpieczeństwo czasu. Nikt nie może po cichu zmienić nazwy właściwości i złamać logiki kodu. Teraz możemy użyć nameof ().

Ma to zaletę, gdy używasz ASP.Net MVC. Kiedy używasz pomocnika HTML do zbudowania kontroli, używa nazw właściwości w atrybucie nazwy danych wejściowych HTML:

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

To sprawia, że ​​coś takiego:

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

Jeśli teraz chcesz zweryfikować swoją właściwość za pomocą metody Validate, możesz to zrobić:

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

W przypadku zmiany nazwy nieruchomości za pomocą narzędzi do refaktoryzacji weryfikacja nie zostanie naruszona.

Innym przykładem użycia nameofjest sprawdzenie stron kart, zamiast sprawdzania indeksu można sprawdzić Namewłaściwości stron kart w następujący sposób:

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

Mniej bałaganu :)

Uważam, że nameofzwiększa to czytelność bardzo długich i złożonych instrukcji SQL w moich aplikacjach. To sprawia, że ​​zmienne wyróżniają się z tego morza ciągów znaków i eliminuje zadanie polegające na ustaleniu, gdzie zmienne są używane w instrukcjach 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 },
    }
}