Was ist der Zweck von nameof?

Es ist wirklich nützlich für ArgumentException und seine Derivate:

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

Nun, wenn jemand refactors die Namen der input parameter der Ausnahme, gehalten werden up-to-date zu sein.

Ist es auch nützlich, in einigen Orten, wo zuvor Reflexion eingesetzt werden musste, um die Namen der Eigenschaften oder Parameter.

In deinem Beispiel nameof(T) ruft den Namen des Parameters "type" - dies kann nützlich sein, zu:

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

Anderen Nutzung nameof ist für Enumerationen, die - in der Regel, wenn Sie möchten, dass die Zeichenfolge ist der name einer enum-verwenden Sie .ToString():

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

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

> "FooBar"

Dies ist eigentlich relativ langsam .Netto hält die enum-Wert (d.h. 7) und findet den Namen zur Laufzeit.

Stattdessen nameof:

Console.WriteLine(nameof(MyEnum.FooBar))

> "FooBar"

Nun .Net ersetzt die enum-name mit einem string zur compile-Zeit.

Noch ein Einsatz ist für Dinge wie INotifyPropertyChanged und die Anmeldung - in beiden Fällen soll der name des Mitglieds, das Sie aufrufen, übergeben werden, auf eine andere Methode:

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

... Oder

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

InformationsquelleAutor der Antwort Keith

Den häufigsten Anwendungsfall, die ich denken kann, ist beim arbeiten mit der INotifyPropertyChanged - Schnittstelle. (Im Grunde alles rund um WPF und Bindungen benutzt diese Schnittstelle)

Werfen Sie einen Blick auf dieses Beispiel:

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

Wie Sie sehen können, in der alten Weise, die wir haben, um eine Zeichenfolge übergeben, um anzugeben, welche Eigenschaft sich geändert hat. Mit nameof können wir den Namen der Eigenschaft direkt. Dies mag nicht wie eine große Sache. Aber Bild, was passiert, wenn jemand ändert den Namen der Eigenschaft Foo. Bei der Verwendung einer Zeichenfolge, die Bindung wird nicht mehr funktionieren, aber der compiler wird nicht warnen Sie. Bei der Verwendung von nameof erhalten Sie einen compiler-Fehler, dass es kein Eigentum/argument mit dem Namen Foo.

Beachten Sie, dass einige frameworks verwenden einige Reflexion Magie, um den Namen der Eigenschaft, aber jetzt haben wir nameof ist dies nicht mehr notwendig.

InformationsquelleAutor der Antwort Roy T.

Häufigste Verwendung wird in der Validierung von Eingaben, wie

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

Im ersten Fall, wenn Sie refactor-Methode ändern par parameter den Namen, die Sie wahrscheinlich vergessen zu ändern, dass in der ArgumentNullException. Mit nameof Sie nicht haben, um sorgen machen.

Siehe auch: nameof (C# und Visual Basic-Referenz)

InformationsquelleAutor der Antwort Massimo Prota

Als andere haben bereits darauf hingewiesen, dass der nameof Betreiber übernimmt Sie den Namen, die das element war in den sourcecode.

Möchte ich hinzufügen, dass dies eine wirklich gute Idee in Bezug auf die Umgestaltung, da macht es diese Zeichenfolge refactoring-safe. Bisher habe ich eine statische Methode, die verwertet Reflexion für den gleichen Zweck, die jedoch nicht, haben eine Laufzeit-performance zu beeinträchtigen. Die nameof Betreiber übernimmt keine Laufzeit-performance auswirken, tut es seine Arbeit auf die compile-Zeit. Wenn Sie einen Blick auf die MSIL - code finden Sie die Zeichenfolge eingebettet. Sehen Sie die folgende Methode, und seine disassemblierten code.

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

Aber das kann von Nachteil sein, wenn Sie planen, zu verschleiern Ihre software. Nach der Verschleierung der embedded-Zeichenfolge kann nicht länger mit dem Namen des Elements. Mechanismen, die sich auf diesen text zu brechen. Beispiele für, die, einschließlich, aber nicht beschränkt auf: Reflexion, NotifyPropertyChanged ...

Bestimmung der Namen während der Laufzeit kostet etwas Leistung, aber ist sicher für Verschleierung. Wenn Verschleierung ist weder erforderlich noch geplant, ich würde empfehlen, die Wahl zu verwenden, die nameof Betreiber.

InformationsquelleAutor der Antwort cel sharp

In dem MSDN-Artikel Listen MVC routing (das Beispiel, das wirklich angeklickt wird das Konzept für mich) unter mehreren anderen. Die (formatierte) Beschreibung Absatzes liest:

• Wenn die Berichterstattung Fehler im code,
• anschließen model-view-controller (MVC) links,
• feuern Eigenschaft verändert Ereignisse, etc.,

oft möchten Sie
erfassen der string der name einer Methode. Mit nameof hilft halten Sie Ihren code
gültig beim umbenennen von Definitionen.

Bevor Sie hatte die Verwendung von string-literalen
beziehen sich auf Definitionen, die spröde beim umbenennen von code-Elementen
weil die tools nicht wissen, um zu überprüfen, diese string-Literale.

Akzeptierten /top bewerteten Antworten geben bereits einige sehr gute und konkrete Beispiele.

InformationsquelleAutor der Antwort brichins

Einer der Verwendung von nameof Schlüsselwort für die Einstellung Binding im wpf programmgesteuert.

setzen Binding müssen Sie Path mit string und mit nameof Schlüsselwort, es ist möglich, Umgestalten option.

Zum Beispiel, wenn Sie IsEnable Abhängigkeitseigenschaft in Ihrem UserControl und Sie wollen binden Sie es an IsEnable einige CheckBox in Ihrem UserControl können Sie verwenden Sie diese zwei codes:

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

und

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

Es ist offensichtlich, dass die erste code kann nicht umgestalten, aber die secend...

InformationsquelleAutor der Antwort Mehdi Khademloo

Es hat Vorteile, wenn Sie verwenden ASP.Net MVC. Wenn Sie HTML-helper zu bauen, eine gewisse Kontrolle in Sicht es nutzt die property-Namen in name attribure der html-Eingabe:

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

Macht es etwas wie das:

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

So, jetzt, wenn Sie brauchen, um zu überprüfen, Ihre Immobilie in der Validate-Methode, die Sie dies tun können:

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

Im Falle dass, wenn Sie benennen Sie die Eigenschaft mithilfe von refactoring-tools, die Ihre Validierung nicht gebrochen werden.

InformationsquelleAutor der Antwort digizard