Nameof'in amacı nedir?

Sürüm 6.0 yeni bir özellik var nameof, ama sadece değişken adını alır ve derleme bir dize olarak değiştirir gibi amacını anlayamıyorum.

Kullanırken bir amacı olabileceğini düşündüm <T>ama denediğimde nameof(T)bana Tkullanılan tipin yerine yazdırıyor .

Amaç hakkında bir fikrin var mı?

Örneğin, bir özellik adına dayalı istisna atarken veya bir PropertyChangedolayı işlerken, bir mülkün adını yeniden kullanmak istediğiniz durumlara ne dersiniz ? Mülkün adını almak istediğiniz çok sayıda durum vardır.

Bu örneği ele alalım:

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

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

İlk durumda, yeniden adlandırma SomeProperty özelliğin da değiştirir veya derlemeyi bozar. Son durum böyle değil.

Bu kod derleme ve hata ücretsiz (sıralama) tutmak için çok yararlı bir yoludur.

( Eric Lippert'ten çok güzel bir makale neden infoofyapmadı, neden nameofyapmadı)

ArgumentExceptionVe türevleri için gerçekten yararlıdır :

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

Şimdi birisi inputparametrenin adını yeniden düzenlerse istisna da güncel tutulur.

Özelliklerin veya parametrelerin adlarını almak için daha önce yansımanın kullanılması gereken bazı yerlerde de yararlıdır.

Örnekte nameof(T)tipi parametresinin adını alır - bu çok yararlı olabilir:

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

Diğer bir kullanımı da nameofnumaralandırmalar içindir - genellikle kullandığınız bir numaralandırmanın dize adını istiyorsanız .ToString():

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

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

> "FooBar"

.Net enum değerini (yani 7) tutar ve adı çalışma zamanında bulur.

Bunun yerine kullanın nameof:

Console.WriteLine(nameof(MyEnum.FooBar))

> "FooBar"

.Net derleme zamanında enum adını bir dizeyle değiştirir.

Yine başka bir kullanım INotifyPropertyChangedve günlüğe kaydetme için kullanılır - her iki durumda da, aradığınız üyenin adının başka bir yönteme geçirilmesini istersiniz:

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

Veya...

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

nameofC # 6.0 özelliğinin kullanışlı olduğu başka bir kullanım durumu - DB alımlarını çok daha kolaylaştıran Dapper gibi bir kütüphane düşünün . Bu harika bir kütüphane olsa da, sorgu içindeki özellik / alan adlarını sabitlemeniz gerekir. Bunun anlamı, mülkünüzü / alanınızı yeniden adlandırmaya karar verirseniz, sorguyu yeni alan adlarını kullanacak şekilde güncellemeyi unutacağınız yüksek olasılıktır. Dize enterpolasyonu ve nameofözellikleri ile kodun bakımı ve yazımı çok daha kolay hale gelir.

Bağlantıda verilen örnekten

isimsiz

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

nameof ile

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

Sorunuz zaten amacı ifade ediyor. Bunun, günlüğe kaydetme veya istisnalar atmada yararlı olabileceğini görmelisiniz.

Örneğin.

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

Bu iyidir, değişkenin adını değiştirirseniz kod yerine kırılacak veya yanlış bir mesajla bir istisna döndürecektir .

Tabii ki, kullanımlar bu basit durumla sınırlı değildir. nameofBir değişkenin veya özelliğin adını kodlamanın ne zaman yararlı olacağını kullanabilirsiniz .

Çeşitli bağlama ve yansıma durumlarını düşündüğünüzde kullanımlar çok çeşitlidir. Zaman derlemek için çalışma zamanı hataları ne getirmek için mükemmel bir yoldur.

Aklıma gelen en yaygın kullanım durumu INotifyPropertyChangedarayüzle çalışırken . (Temel olarak WPF ve bağlarla ilgili her şey bu arayüzü kullanır)

Bu örneğe bir göz atın:

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

Eski şekilde görebileceğiniz gibi, hangi özelliğin değiştiğini belirtmek için bir dize geçirmeliyiz. İle nameofdoğrudan mülkün adını kullanabiliriz. Bu büyük bir şey gibi görünmeyebilir. Ancak birileri mülkün adını değiştirdiğinde ne olacağını hayal edin Foo. Bir dize kullanırken ciltleme durur ancak derleyici sizi uyarmaz. Nameof kullanırken, ad ile hiçbir özellik / argüman yok derleyici hatası alırsınız Foo.

Bazı çerçevelerin, mülkün adını almak için bazı yansıma sihirleri kullandığını unutmayın, ancak şimdi bunun gerekli olmadığını anladık .

En yaygın kullanım, giriş doğrulamasında olacaktır.

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

İlk durumda, par parametresinin adını değiştiren yöntemi yeniden düzenlerseniz , bunu ArgumentNullException içinde değiştirmeyi unutursunuz . İle NameOf Bu konuda endişe gerekmez.

Ayrıca bkz: nameof (C # ve Visual Basic Başvurusu)

ASP.NET Çekirdek MVC projesi kullanır nameofolarak AccountController.csve ManageController.csbirlikte RedirectToActionkontrol cihazı bir eylem referans yöntemi.

Misal:

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

Bu şu anlama gelir:

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

ve yani 'Ev' denetleyicisi, içinde 'Dizin' eylem için kullanıcı alır alır /Home/Index.

Diğerlerinin de belirttiği gibi, nameofoperatör öğenin kaynak koduna verildiği adı ekler.

Bu dize yeniden düzenleme güvenli yapar çünkü bu yeniden düzenleme açısından gerçekten iyi bir fikir olduğunu eklemek istiyorum. Daha önce, aynı amaçla yansımayı kullanan, ancak çalışma zamanı performansı etkisi olan statik bir yöntem kullanıyordum. nameofOperatör bir çalışma zamanı performans etkisi vardır; derleme zamanında işini yapar. Eğer MSILkoda bir göz atarsanız, gömülü dizeyi bulacaksınız. Aşağıdaki yönteme ve sökülmüş koduna bakın.

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

Ancak, yazılımınızı gizlemeyi planlıyorsanız bu bir dezavantaj olabilir. Gizleme sonrasında gömülü dize artık öğenin adıyla eşleşmeyebilir. Bu metne dayanan mekanizmalar kırılacaktır. Bunlara örnekler, bunlarla sınırlı olmamak üzere aşağıdakileri içerir: Yansıma, NotifyPropertyChanged ...

Çalışma zamanı sırasında adın belirlenmesi biraz performans gerektirir, ancak gizleme için güvenlidir. Ne şaşkınlık ne de planlanmışsa nameofoperatörün kullanılmasını tavsiye ederim .

Kodunuzda bir değişken kullandığınızı ve değişkenin adını almanız gerektiğini düşünün ve diyelim ki yazdırın, şunu kullanmalısınız:

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

Ve sonra birisi kodu yeniden düzenler ve "myVar" için başka bir ad kullanırsa, kodunuzdaki dize değerini izlemesi ve buna göre chenge etmesi gerekir.

Bunun yerine

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

Bu otomatik olarak refactor yardımcı olacaktır!

MSDN makalesinde , diğerleri arasında MVC yönlendirmesi (benim için konsepti gerçekten tıklayan örnek) listelenmektedir. (Biçimlendirilmiş) açıklama paragrafında şunlar bulunur:

• Koddaki hataları bildirirken,
• Model-view-controller (MVC) bağlantılarını bağlamak,
• ateşleme özelliği değişti olayları, vb.

genellikle bir yöntemin dize adını yakalamak istersiniz . Nameof kullanımı , tanımları yeniden adlandırırken kodunuzun geçerli kalmasına yardımcı olur .

Önce , kod öğelerini yeniden adlandırırken gevrek olan tanımlara başvurmak için dize değişmezlerini kullanmak zorunda kaldınız çünkü araçlar bu dize değişmez değerlerini kontrol etmeyi bilmiyor.

Kabul edilen / en çok puan alan cevaplar zaten birkaç mükemmel somut örnek veriyor.

nameofOperatörün amacı , eserlerin kaynak adını vermektir.

Genellikle kaynak adı meta veri adıyla aynı addır:

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

Ancak bu her zaman böyle olmayabilir:

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

Veya:

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

Buna verdiğim bir kullanım, kaynakları adlandırmaktır:

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

Gerçek şu ki, bu durumda, kaynaklara erişmek için oluşturulan özelliklere bile ihtiyacım yoktu, ama şimdi kaynakların var olup olmadığını kontrol etmek için bir derleme zamanım var.

nameofAnahtar kelime kullanımından biri Bindingwpf'de programlı olarak ayarlamak içindir .

sete Bindingsete zorunda Pathdize ile ve ilenameof anahtar kelime ile, Refactor seçeneğini kullanmak mümkündür.

Örneğin, cihazınızda IsEnablebağımlılık özelliği varsa UserControlve bunu alanınızdaki IsEnablebazı kullanıcılara bağlamak istiyorsanız, şu iki kodu kullanabilirsiniz:CheckBoxUserControl

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

ve

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

Açıkçası ilk kod refactor olamaz ama secend bir ...

Daha önce böyle bir şey kullanıyorduk:

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

Sebep - zaman güvenliğini derleyin. Hiç kimse sessizce özelliği yeniden adlandıramaz ve kod mantığını bozamaz. Şimdi nameof () kullanabiliriz.

ASP.Net MVC kullandığınızda avantajı vardır. Görünümde bir denetim oluşturmak için HTML yardımcısını kullandığınızda, html girdisinin ad özelliğinde özellik adlarını kullanır:

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

Böyle bir şey yapar:

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

Şimdi, mülkünüzü Validate yönteminde doğrulamanız gerekiyorsa, bunu yapabilirsiniz:

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

Yeniden düzenleme araçlarını kullanarak mülkünüzü yeniden adlandırırsanız, doğrulama işleminiz bozulmaz.

Diğer bir kullanım durumu nameofsekme sayfalarını kontrol etmektir, dizini kontrol etmek yerine sekmelerin sayfalarını aşağıdaki gibi kontrol edebilirsiniz Name:

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

Daha az dağınık :)

Uygulamalarımdaki nameofçok uzun ve karmaşık SQL ifadelerinin okunabilirliğini artırdığını görüyorum . Değişkenleri o dizelerden farklı kılar ve SQL ifadelerinizde değişkenlerin nerede kullanıldığını bulma işinizi ortadan kaldırır.

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 },
    }
}