ReSharper neden her şey için 'var' kullanmak istiyor?

Visual Studio ile ReSharper kullanmaya yeni başladım (SO ile ilgili birçok öneriden sonra). Denemek için yeni bir ASP.NET MVC projesi açtım. Bunu öne sürdüğünü fark ettiğim ilk ve en sık şeylerden biri, açık beyanlarımın çoğunu / varyerine değiştirmek. Örneğin:

//From This:
MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);
//To This:
var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

ve benzeri, hatta basit tipleri böyle ile int, boolvb

Bu neden öneriliyor? Son zamanlarda bir bilgisayar bilimi veya .NET geçmişinden gelmedim, son zamanlarda .NET geliştirmeye "düştüm", bu yüzden neler olup bittiğini ve fayda olup olmadığını anlamak istiyorum.

Bunun bir nedeni daha iyi okunabilirliktir. Hangisi daha iyi?

Dictionary<int, MyLongNamedObject> dictionary = new Dictionary<int, MyLongNamedObject>();

veya

var dictionary = new Dictionary<int, MyLongNamedObject>();

ReSharper'ın önerdiği, var anahtar kelimesinin aşırı kullanımı. Bunu türün açık olduğu yerlerde kullanabilirsiniz:

var obj = new SomeObject();

Tür açık değilse, yazmayı tercih etmelisiniz:

SomeObject obj = DB.SomeClass.GetObject(42);

Şahsen bu öneriyi kapatmayı tercih ediyorum. Kullanımı vargenellikle okunabilirliği artırabilir; ancak bahsettiğiniz gibi, bazen azalır (basit türlerle veya ortaya çıkan tür belirsiz olduğunda ).

Ne zaman kullanacağımı varve ne zaman kullanmamayı tercih ederim . Ama yine, bu sadece benim.

varkodun anında anlaşılmasını azaltırken kodun okunabilirliğini artırabilir. Aynı şekilde, diğer durumlar için kodun okunabilirliğini azaltabilir. Bazen kullanımı tarafsızdır. Anlamaya okunabilirlik ölçüsü orantılı değildir, ancak duruma bağlıdır. Bazen ikisi birlikte artar veya azalır.

Faktör, neyin varuygulandığı ve hedefin, veri türünün okuyucuya anında gizlenmesini ne kadar iyi desteklediğini veya eldeki program bölümünü anlamak için tür bilgisine ihtiyaç duyulup duyulmadığıdır.

Örneğin, kötü adlandırma var, kodun anlaşılmasını azaltmaya neden olabilir . Bu bir varhata değildir :

var value1 = GetNotObviousValue(); //What's the data type? 
//vs. 
var value2 = Math.Abs(-3); // Obviously a numeric data type. 

Bazen varkod yokluğunda daha okunabilir olduğunda basit veri türleri için kullanmak mantıklı değildir :

var num = GetNumber(); // But what type of number?
// vs. 
double num = GetNumber(); // I see, it's a double type. 

Bazen var, karmaşıklıklarını görmek için umursamadığınız veri türü bilgilerini gizlemek için yararlı olabilir:

    IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> q = from t in d where t.Key == null select t; // OMG! 
    //vs. 
    var q = from t in d where t.Key == null select t;

    // I simply want the first string, so the last version seems fine.  
    q.First().Key; 

Sen gerekir kullanmak vartarafından olduğunu söylemek hiçte tür adı var, çünkü anonim bir tür mevcut olduğunda:

var o = new { Num=3, Name="" };

Buna rağmen tür bilgisi sağlayan Visual Studio Intellisense'e sahip olduğunuzda, varyardım almadan katı kod okuma yoluyla anlayışınıza daha az güvenmeniz gerekir. Muhtemelen herkesin Intellisense'e sahip olamayacağını veya kullanamayacağını düşünmek akıllıca olacaktır.

Özetle yukarıdaki örneklere dayanarak, carte blanche uygulamasının variyi bir fikir olmadığını önerebilirim , çünkü çoğu şey en iyi şekilde ılımlı olarak yapılır ve burada gösterilen duruma dayanır.

Resharper neden varsayılan olarak her şeyi kullanıyor? Kolaylığı öneririm, çünkü en iyi ne zaman kullanılamayacağına karar vermek için durumların nüanslarını ayrıştıramaz.

ReSharper'da (8.02, ancak muhtemelen diğer sürümler), "Örtük olarak yazılan yerel değişken bildirimini kullan" önerisi seçeneği , ne olursa olsun, önce ReSharper için seçenekler menüsünü açarak tercihinize göre ayarlanabilir :

Sonra, "Kod İnceleme" altında, seçtiğiniz dilin "İnceleme Şiddeti" ni ayarlayarak, benim durumumda c #:

Gördüğünüz gibi, ReSharper'ın sunduğu tüm önerileri ayarlama seçenekleri vardır. Bu benim gibi birine zaten 'var' kullanım stratejisi olan ve ReSharper'ın buna saygı duymasını isteyen birine yardımcı olacağını umuyor :)

Kimsenin somut nesnenin türünü değiştirmenin daha kolay olduğunu söylemediğine şaşırdım, çünkü

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

bir tekrarlama şeklidir . Eğer AVeryLongTypeNametüretilmiş sınıflarından birine geçmek isterseniz , bunu kullanırken sadece bir kez değiştirmem gerekir varve yine de alt sınıfların yöntemlerine erişebilirsiniz.

Bunun yanı sıra, daha iyi okunabilirlik önemli bir noktadır, ancak diğerlerinin söylediği gibi var aşırı kullanılmamalıdır, bu yüzden Resharper'da ipucunu kapatmak kesinlikle tamam.

'var' açık olmakla ilgilidir

varAnahtar kelimenin kullanılıp kullanılmayacağı hakkındaki ana tartışma , kodun size ve diğer geliştiricilere ne kadar okunabilir olduğu ile ilgilidir.

Bir hikaye yazıyormuşsunuz gibi kesin bir doğru cevap yoktur. Ancak bunun bazı örneklerine basit İngilizce olarak bakalım.

Jake, Bill'e merhaba dedi. Onu sevmediği için döndü ve diğer tarafa gitti.

Kim diğer tarafa gitti? Jake mi Bill mi? Bu durumda "Jake" ve "Bill" adlarını kullanmak, tür adını kullanmak gibidir. "O" ve "o" varanahtar kelimeyi kullanmak gibidir . Bu durumda daha spesifik olmak yardımcı olabilir. Örneğin aşağıdakiler çok daha net.

Jake, Bill'e merhaba dedi. Jake Bill'i sevmediği için döndü ve diğer tarafa gitti.

Bu durumda daha açık olmak cümleyi daha açık hale getirdi. Ama bu her zaman böyle olmayacak. Bazı durumlarda spesifik olmak okumayı zorlaştırır.

Bill kitapları sever, bu yüzden Bill kütüphaneye gitti ve Bill Bill'in hep sevdiği bir kitap çıkardı.

Bu durumda, "o" kelimesini kullanırsak ve bazı durumlarda adını bir arada bırakırsak, bu varanahtar kelimeyi kullanmaya eşdeğerse cümleyi okumak daha kolay olurdu .

Bill kitapları sever, bu yüzden kütüphaneye gitti ve her zaman sevdiği bir kitap çıkardı.

Bu örnekler özü kapsar, ancak tüm hikayeyi anlatmazlar. Bu örneklerde kişiye atıfta bulunmanın yalnızca bir yolu vardı. Ya adlarını kullanarak ya da "o" ve "kendisi" gibi daha genel bir terim kullanarak.

Kod söz konusu olduğunda, netlik sağlamaya yardımcı olmak için 3 yolumuz var. Tür, değişken adı ve atama. Örneğin bu kod satırını ele alalım:

Person p = GetPerson();

Şimdi soru şu oluyor, bu kod satırında neler olup bittiğini anlamanıza yardımcı olacak yeterli bilgi var mı?

Aşağıdaki kod satırı ne olacak? pBu durumda ne anlama geldiğini hala biliyor musunuz :

var p = GetPerson();

Şimdi nasıl:

var p = Get();

Veya şimdi:

var person = Get();

Ya da bu:

var t = GetPerson();

Veya bu:

var u = Person.Get();

Anahtar kelimenin varbelirli bir senaryoda çalışıp çalışmadığı, değişkenlerin, sınıfların ve yöntemlerin nasıl adlandırıldığı gibi, kodun içeriğine büyük ölçüde bağlıdır. Ayrıca kodun karmaşıklığına ve onu çevreleyen kodun geri kalanına da bağlıdır.

Şahsen ben çoğu zaman benim içinvar daha kapsamlı bir anahtar kelime kullanmak istiyorum . Ama aynı zamanda değişkenlerimi türden sonra adlandırmaya eğilimliyim, bu yüzden gerçekten herhangi bir bilgi kaybetmiyorum.

Bazen istisna yaptığım bağlama bağlı olarak, karmaşık olan her şeyin doğası ve karmaşık olmasa bile yazılım hiçbir şey söylenmediğini söyledi.

Bunu da sevmedim.

Bunun kullanımı hakkında bir tartışmaya dönüşmesini istemiyorum, kullanımları varvar, ancak her yerde kullanılmamalıdır.

Hatırlanması gereken en önemli şey, ReSharper'ın istediğiniz kodlama standartlarına göre yapılandırılmış olmasıdır.

Düzenleme: ReSharper ve var

Birçok doğru cevabı görüyorum, ama tam cevabı kaçırıyorum.

ReSharper'ın varvarsayılan olarak aşırı kullanmış olduğu doğrudur . Sanırım çoğu insan buna katılıyor. Ayrıca, ne zaman varkullanıldığını okumak da daha kolaydır ve tür bir newdeyim kullandığınızda açıktır . İnceleme şiddetinin nasıl kullanılacağına dair ipuçlarını nasıl güncelleyeceğini gösteren bir yazı gördüm var.

Bunları nereye koyacağımı eklemek için önce diğer yazılara yorum yapmaya çalıştım ama bununla ün yapmadım. Görünüşe göre, ayarların ekran görüntüsünü yayınlama konusunda da itibarım yoktu.

Oraya nasıl gidileceğini açıklayacağım.

Visual Studio> Ana Menü> Yeniden Paylaşıcı> Seçenekler> Kod Düzenleme> C #> Kod Stili> Bildirimlerde Var Kullanımı

• Yerleşik türler için Açık türü kullanın
• Basit tipler için Belli olduğunda 'var' kullanın
• Başka Bir Yerde 'Var' Kullanın

ReSharper yardım belgeleri: Kod Sözdizimi Stili: Örtük / Açık Yazma ('var' Anahtar Kelime) - 'var' anahtar kelimesini kullanma tercihlerini yapılandır

Kuralım şudur:

• Eğer (yani ilkel türü bildiriyorlar byte, char, string, int[], double?, decimal, vs.)? -> Türü kullanın:

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  double? myDouble = 123.3;

• Eğer karmaşık bir türü bildiriyorlar (yani List<T>, Dictionary<T, T>, MyObj)? -> Kullanım var:

  var myList = List<string>();
  var myDictionary = Dictionary<string, string>();
  var myObjInstance = new MyObj();

Sadece C # Kodlama Kurallarında "var" kullanımının önerildiğini belirtmek isterim

değişkenin türü atamanın sağ tarafından belli olduğunda veya kesin tür önemli olmadığında

bu yüzden muhtemelen ReSharper'da ipucu varsayılan olarak açıktır. Ayrıca, aynı belgede okunabilirliği iyileştirmeyeceği bazı durumlar da sunmaktadır.

ReSharper, varnesne oluşturmayı karmaşık hale getirdiği için önermektedir .

Bu iki örneği karşılaştırın:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Okuması daha kolay olması gereken bir stenografi.

Ben açıkça "yeni" ile yeni nesneler oluşturmak için iyi olduğunu düşünüyorum. Ancak örneğinizde, sınıfların düzgün adlandırılmamış olması açık olmayabilir.

BTW, ReSharper 'bu öneriyi kodunuza uygulamak isteyebilirsiniz' ve 'kodunuz bozuk, düzeltmemi ister misiniz?' Arasında bir ayrım çiziyor. varAnahtar kelime "eğer invert yuvalama azaltmak için" gibi şeyler ile birlikte öneri kategorisinde ise; takip etmek zorunda değilsiniz.

Her uyarısının ne kadar can sıkıcı olacağını Seçenekler iletişim kutusundan veya doğrudan bu uyarı için açılır menüden yapılandırabilirsiniz. varÖneri gibi şeyleri daha az belirgin olacak şekilde eski sürüme geçirebilir veya 'uzantı yöntemini kullan' uyarısı gibi şeyleri gerçek bir hata olarak görünecek şekilde yükseltebilirsiniz.

var.NET 3.0 özelliği adildir tür kesmesi türü güvenlidir ve genellikle okumak için kod kolaylaştırır. Ancak bunu yapmak zorunda değilsiniz ve isterseniz bu tavsiyeyi yeniden paylaşımda kapatabilirsiniz.

Var inanılmaz! Ben vardinamik bir tür bağlı izlenim altında birçok geliştirici rastladım , öyle değil. Hala statik olarak yazılmıştır, sadece derleyici tarafından kararlaştırılır.

İşte var kullanmanın bazı şaşırtıcı pozitifleri

Daha az yazarak değişken daha kısa ve okunması daha kolaydır, örneğin

Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>()Yuk.

var postcodes = new Dictionary<int,IList<string>>()\ o / \ o /

Daha açıklayıcı değişken isimleri - yavaş bir tane ama varburada sıvı doğanın parlamasına izin vermenin önemli olduğunu düşünüyorum . varBiraz belirsiz olduğu gibi , türün kendisi için konuşmasına izin vermek yerine gerçekten daha değişken bir değişken adını teşvik eder.

Daha az kod değişikliği - bir yöntem çağrısının dönüş türü değişirse. Kullanıldığı her yerde yalnızca yöntem çağrısını değiştirmeniz gerekir.

Anonim türler - anonim türler, özellikle WebApi kısmi kaynakları gibi alanlarda gerçekten güçlü bir kavramdır . Var olmadan kullanılamazlar.

Ancak bazen türleri açıkça tanımlamak yararlı olur ve bunu ilkel veya yapılarda en yararlı buluyorum. Örneğin, kişisel olarak bu sözdizimini çok kullanışlı bulmuyorum:

for(var i = 0; i < 10; i++) 
{

}

vs

for(int i = 0; i < 10; i++) 
{

}

Her şey kişisel tercihe bağlıdır, ancak vargerçekten kullanmak gelişiminizi hızlandıracak ve anonim bir tür iyilik dünyasının kilidini açacaktır.

Teknik bir fark yoktur, var kullanırsanız, tür derleyici tarafından ima edilir. Bunun gibi bir kodunuz varsa:

var x = 1;

x bir int olarak ima edilir ve buna başka bir değer atanamaz.

Değişkenin türünü değiştirirseniz var anahtar sözcüğü yararlı olur; o zaman iki yerine sadece bir değişiklik yapmanız gerekir:

var x = 1; --> var x = "hello";
int x = 1; --> string x = "hello";

varAnahtar kelime C # 3.0 tanıtıldı - açıkça bizim türünü belirterek unutmak için bize izin verir.

Kullanıp kullanmamanız arasında gerçek bir fark yok

MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

veya

var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

saf okunabilirlik ve hata olasılığının azalması hariç.

Klişe bir örnek gibi görünüyor, ancak aşağıdakilerin anlayışınıza yardımcı olabileceğini söyleyin:

var myInt = 23;

bir inttür döndürür

var myInt = "23";

bir stringtür döndürür .

MSDN başvurusu

Açık bir nesne türü belirtmek bir şekilde gereksizdir. İngilizce'ye çevrilmiş olsa bile, kulağa gereksiz geliyor: "X tipi bir nesneyi X tipi bir değişkene koy" vs "X tipi bir nesneyi bir değişkene koy".

Ancak, 'var' kullanmanın sınırlamaları vardır . Bu aşağıda kullanımını engelleyen polimorfizmi olan saf güzellik :

Bir köpeğin hayvanı uzattığını varsayın; Cat, Animal sınıfı hiyerarşisini genişletir:

Animal x = new Dog();
DoStuffWithDog(x as Dog);

x = new Cat();
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

Aynı kod, 'var' ile bildirilen x ile derlenmeyecektir .

var x = new Dog(); // from this point, x is a Dog
DoStuffWithDog(x as Dog);

x = new Cat(); // cannot assign a Cat instance to a Dog
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

Her neyse, asıl soruya dönersek, Resharper kullanmıyorum, ama 'var' ne zaman kullanılmayacağını algılayacak kadar akıllı olduğunu varsayıyorum. :-)

Bana göre, var sadece değişkenin değerini tanımlarken türün ne olduğu hemen anlaşılır olduğunda kullanılmalıdır.

Misal:

var s = "string value";

Bunun sa string.

Değişken türü adı çok karmaşık olduğunda da uygun olduğuna inanıyorum.

Misal:

Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

// This is a little easier to read than the above statement
var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

Bu senaryoların dışında, kullanarak herhangi bir KAZANIM görmüyorum var, ancak zararlı olabileceği bazı senaryoları düşünebilirim:

Örneğin, sağ taraftaki değişken değeri türü açıkça göstermeyen tek kullanımlık bir tür. IDisposable'ın imhası kolayca unutulabilir

Misal:

// returns some file writer
var wr = GetWriter();

wr.add("stuff");
wr.add("more stuff");

//...
//...

// Now `wr` needs to be disposed, 
// but there is no clear indication of the type of `wr`,
// so it will be easily overlooked by code writer and code reviewer.

'var', kodunuza bir tür "dinamik" öğe ekler (her ne kadar kod kesinlikle yazılsa da). Tipin net olmadığı durumlarda kullanmaya karşı tavsiye ederim. Bu örneği düşünün:

var bar = GetTheObjectFromDatabase();
bar.DoSomething();

ClassA {
  void DoSomething() {
  //does something
  }
}

ClassB {
  void DoSomething() {
  //does something entirely different
  }
}

GetTheObjectFromDatabase () türünün Type A'dan B'ye değiştirilmesi durumunda her iki Sınıf da DoSomething () uyguladığından fark etmeyeceğiz. Ancak kod artık tamamen farklı bir şey yapabilir.

Bu, her ikisi de günlüğe farklı şeyler yazmak kadar ince olabilir, bu yüzden çok geç olduğunu fark etmeyebilirsiniz.

Aşağıdaki var kullanımı her zaman iyi olmalıdır:

var abc = new Something();

"Var" ın sürekli kullanımını beğenmeyenler için, "giriş değişkeni" yaparken ReSharper'ın varsayılan olarak var ayarını durdurabilirsiniz. Bu beni uzun süre hayal kırıklığına uğratan bir şeydi, her zaman var olması varsayılandı ve her seferinde değiştirdim.

Bu ayarlar Kod Düzenleme> C #> Kod Stili altında

Teknik bir fark yoktur (eWolf'un belirttiği gibi). Birini veya diğerini kullanabilirsiniz, oluşturulan CLR kodu aynı görünecektir.

Kanımca, bunun en önemli yararı, bunun sizi daha iyi değişken isimlendirme kullanmaya zorlamasıdır. Örneğinizde 'foo' değişken adı için oldukça zayıf bir seçimdir.

JetBrains'e (ReSharper'in yazarı) göre, var kullanımını varsayılan olarak teşvik ediyorlar.

Gönderen kendi web sitesinde :

varC # 3.0'da sunulan örtük olarak yazılan yerel değişkenlerin ( anahtar sözcük olarak da bilinir ) kullanılması, birçok senaryoda okunabilirliği geliştirdiği için oldukça popüler hale gelmiştir. Varsayılan olarak ReSharper, varanahtar kelime kullanımını da teşvik eder , ancak kullanım tercihleri ​​esnek bir şekilde yapılandırılabilir - örneğin, belirli durumlarda veya her yerde açık türleri kullanmayı tercih edebilirsiniz ve ReSharper tercihlerinizi uygulamanıza yardımcı olacaktır.