Dlaczego ReSharper chce używać' var ' do wszystkiego?

ReSharper sugeruje wyraźnie nadużywanie słowa kluczowego var. Można go używać tam, gdzie typ jest oczywisty:

var obj = new SomeObject();

Jeśli Typ nie jest oczywisty, powinieneś raczej napisać:

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

Ja osobiście wolę wyłączyć tę sugestię. Użycie var może często poprawić czytelność; ale jak już wspomniałeś, czasami ją zmniejsza(z typami prostymi lub gdy typem wynikowym jest obscure ).

Wolę wybierać, kiedy używam var, a kiedy nie. ale znowu, to tylko ja.

var może zwiększyć czytelność kodu, jednocześnie zmniejszając natychmiastowe zrozumienie kodu. Tak samo, może zmniejszyć czytelność kodu w innych sytuacjach. Czasami jego użycie jest neutralne. Miara czytelności do zrozumienia nie jest proporcjonalna, ale zależy od sytuacji. Czasami oba są zwiększone lub zmniejszone razem.

Czynnikiem jest to, co var jest stosowane do i jak dobrze cel obsługuje natychmiastowe zaciemnienie swojego typu danych do czytnika, lub jeśli informacje o jego typie są potrzebne, aby zrozumieć część programu pod ręką.

Na przykład złe nazewnictwo może prowadzić do var, powodując zmniejszenie zrozumienia kodu. Nie jest to jednak wina var:

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

Czasami nie ma sensu używać var dla prostych typów danych, gdy kod jest bardziej czytelny przy jego braku:

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

Czasami var może być przydatne do ukrycia informacji typu danych, które niekoniecznie dbają o szczegóły:

    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; 

You must use var when there 's anonymous type present because there' s no type name to call it by:

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

Gdy masz Visual Studio Intellisense dostarczające informacje o typie pomimo var, musisz wtedy mniej polegać na swoim zrozumieniu poprzez ścisłe czytanie kodu bez pomocy. Prawdopodobnie mądrze jest założyć, że nie każdy może mieć lub używać Intellisense.

Podsumowując, bazując na powyższych przykładach, proponuję stosowanie var nie jest dobrym pomysłem, ponieważ większość rzeczy najlepiej robić z umiarem i w oparciu o okoliczności pod ręką, jak pokazano tutaj.

Dlaczego Resharper używa go domyślnie? Sugerowałbym dla ułatwienia, ponieważ nie może analizować niuansów sytuacji, aby zdecydować, kiedy najlepiej go nie używać.

W ReSharper (8.02, ale prawdopodobnie inne wersje), opcja sugestii "Use implicite typed local variable declaration" może być dostosowana do Twoich preferencji , cokolwiek by to nie było, najpierw otwierając menu opcji dla ReSharper:

Następnie, w "kontrola kodu", dostosowując "dotkliwość kontroli" wybranego języka, w moim przypadku c#:

Jak widać, istnieją opcje, aby dostosować wszystkie sugestie, które ReSharper sprawia. Mam nadzieję, że pomoże to komuś takiemu jak ja, kto ma już strategię użycia " var " i chce tylko, aby ReSharper ją uszanował:)

'var' jest o byciu jasnym

Główna debata o tym, czy używać słowa kluczowego var, czy nie, dotyczy tego, jak czytelny jest kod dla Ciebie i innych programistów.

Tak, jakbyś pisał historię, nie ma ostatecznej właściwej odpowiedzi. Ale spójrzmy na kilka przykładów tego w prostym języku angielskim.

Jake przywitał się z Billem. Nie lubił go, więc odwrócił się i poszedł w drugą stronę.

Jake przywitał się z Billem. Jake nie lubił Billa, więc odwrócił się i poszedł w drugą stronę.

W tym przypadku bardziej szczegółowe uczyniły zdanie jaśniejszym. Ale nie zawsze tak będzie. W niektórych przypadkach specyfika utrudnia Czytaj.

Bill lubi książki, więc poszedł do biblioteki i wyjął książkę, którą Bill zawsze lubił.

W tym przypadku łatwiej byłoby odczytać zdanie, gdybyśmy użyli "on", a w niektórych przypadkach pominęli jego imię razem, co jest odpowiednikiem słowa kluczowego var.

Bill lubi książki, więc poszedł do biblioteki i wyjął książkę, którą zawsze lubił.

Te przykłady obejmują gist, ale nie opowiedz całą historię. W tych przykładach był tylko jeden sposób odniesienia się do osoby. Albo używając ich nazwy, albo używając bardziej ogólnych określeń, takich jak" on " i "on".

W przypadku kodu mamy 3 sposoby na dodanie jasności. Typ, nazwa zmiennej i przypisanie. Weźmy ten wiersz kodu na przykład:

Person p = GetPerson();

Teraz pojawia się pytanie, czy jest wystarczająco dużo informacji w tej linii kodu, aby pomóc ci dowiedzieć się, co się dzieje?

A co z następującymi linia kodu? Czy nadal wiesz, co p oznacza w tym przypadku:

var p = GetPerson();

A może teraz:

var p = Get();

Lub teraz:

var person = Get();

Lub ten:

var t = GetPerson();

Lub to:

var u = Person.Get();

To, czy słowo kluczowe var działa w danym scenariuszu, zależy w dużej mierze od kontekstu kodu, na przykład od tego, jak zmienne, klasy i metody są nazwane. Zależy to również od złożoności kodu i reszty otaczającego go kodu.

Osobiście lubię używać var słowo kluczowe jest bardziej wyczerpujące dla mnie przez większość czasu. Ale mam również tendencję do nazywania moich zmiennych po typie, więc tak naprawdę nie tracę żadnych informacji.

To powiedziaĹ 'o czasami w zaleĹźnoĹ" ci od kontekstu czyniÄ ™ wyjÄ ... tki, taka jest natura czegokolwiek skomplikowanego, a oprogramowanie jest niczym, jeĹ " li nie jest skomplikowane.

Dziwię się, że nikt nie wspomniał, że łatwiej jest również zmienić typ obiektu instancyjnego, ponieważ

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

Jest formą powtórzenia . Jeśli chcę zmienić AVeryLongTypeName na jedną z jej pochodnych klas, muszę zmienić to tylko raz podczas używania var i nadal mogę uzyskać dostęp do metod klas podrzędnych.

Poza tym, poprawiona czytelność jest ważnym punktem, ale jak mówili inni, var nie powinien być nadużywany, więc myślę, że wyłączenie podpowiedzi w Resharper jest absolutnie ok.

To też mi się nie podobało.

Nie chcę, aby to przerodziło się w debatę na temat użycia var, ma swoje zastosowania, ale nie powinno być używane wszędzie.

Kluczową rzeczą do zapamiętania jest to, że ReSharper jest skonfigurowany do dowolnych standardów kodowania, które chcesz.

Edit: ReSharper i var

Widzę wiele poprawnych odpowiedzi, ale brakuje pełnej.

Próbowałem najpierw skomentować inne posty, aby dodać gdzie je ustawić, ale nie miałem reputacji dla to. Najwyraźniej nie miałem również reputacji, aby opublikować mój zrzut ekranu z ustawieniami.

W Visual Studio > Menu główne > Resharper > opcje > Edycja kodu > C# > Styl kodu > użycie Var w deklaracjach

• dla typów wbudowanych użyj typu jawnego
• dla typów prostych użyj 'var', gdy widoczne
• gdzie indziej użyj ' Var '

ReSharper help documentation: Code Styl składni: niejawne / jawne pisanie (słowo kluczowe 'var' ) - Konfiguracja preferencji użycia słowa kluczowego ' var '

Moja zasada jest taka:

• Czy deklarujesz prymitywny Typ (tzn. byte, char, string, int[], double?, decimal, itd.)? - >Użyj typu:

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

• Czy deklarujesz typ złożony (tj. List<T>, Dictionary<T, T>, MyObj)? - >Użyj var:

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

Chciałbym tylko zaznaczyć, że użycie "var" jest zalecane w konwencji kodowania C #

Gdy typ zmiennej jest oczywisty z prawej strony przypisania, lub gdy dokładny typ nie jest ważny

Więc prawdopodobnie dlatego wskazówka jest domyślnie włączona w ReSharper. Zawierają one również niektóre przypadki, w których nie poprawiłoby to czytelności bezpośrednio poniżej w tym samym dokumencie.

ReSharper zaleca var, ponieważ ma tendencję do odblokowywania tworzenia obiektów.

Porównaj te dwa przykłady:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Myślę, że jest w porządku, gdy tworzysz nowe obiekty jawnie za pomocą "new". Jednak w twoim przykładzie może nie być oczywiste, jeśli klasy nie zostały nazwane poprawnie.

BTW, ReSharper rysuje rozróżnienie między "możesz zastosować tę sugestię do swojego kodu" i " twój kod jest zepsuty, chcesz, żebym to naprawił?'. Słowo kluczowe var znajduje się w kategorii sugestia, wraz z takimi rzeczami jak "Odwróć, Jeśli aby zmniejszyć zagnieżdżanie"; nie musisz go śledzić.

Możesz skonfigurować, jak irytujące są wszystkie alerty w oknie dialogowym Opcje lub bezpośrednio w menu podręcznym dla tego alertu. Można obniżyć takie rzeczy jak sugestia var, żeby były mniej widoczne, lub można uaktualnić rzeczy ,takie jak alert "użyj metody rozszerzenia", aby wyświetlał się jako rzeczywisty błąd.

var funkcja.NET 3.0 jest po prostu wnioskowanie typu , które jest bezpieczne dla typu i często sprawia, że kod jest łatwiejszy do odczytania. Ale nie musisz i możesz wyłączyć tę rekomendację w ReSharper, jeśli chcesz.

Var jest niesamowity! Natknąłem się na wielu programistów, którzy mają wrażenie, że var jest związany z typem dynamicznym, nie jest. Wciąż jest statycznie pisany, tylko o tym decyduje kompilator.

Oto kilka niesamowitych zalet używania var

Mniej typowania var jest krótszy i łatwiejszy do odczytania, na przykład

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

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

bardziej opisowe nazwy zmiennych - wątpliwe, ale myślę, że ważne jest, aby pozwolić fluid nature of var shine here. Ponieważ var jest nieco niejasne, to naprawdę zachęca do bardziej descyptywnej nazwy zmiennej, zamiast pozwalać typowi mówić sam za siebie.

Less code changes - jeśli zmieni się Typ zwracanego wywołania metody. Musisz tylko zmienić wywołanie metody, Nie w każdym miejscu, w którym jest używana.

typy anonimowe - typy anonimowe są naprawdę potężnym pojęciem, szczególnie w obszarach takich jak zasoby częściowe WebApi . Bez var nie mogą być używane.

Czasami jednak warto jasno deklarować typy i uważam to za najbardziej przydatne w prymitywach lub strukturach. Na przykład, osobiście nie uważam tej składni za bardzo przydatną:

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

}

Vs

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

}

Wszystko zależy od osobistych preferencji, ale używanie var naprawdę przyspieszy twój rozwój i odblokuje cały świat anonimowych dobroci typu.

Moim zdaniem, var powinno być używane tylko wtedy, gdy jest od razu jasne, jaki jest typ przy definiowaniu wartości zmiennej.

Przykład:

var s = "string value";

Jest oczywiste, że s jest string.

Uważam, że jest to również właściwe, gdy nazwa typu zmiennej jest bardzo złożona.

Przykład:

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

Poza tymi scenariuszami, nie widzę żadnych korzyści, które można osiągnąć używając var, ale mogę wymyślić kilka scenariuszy, w których może to być

Na przykład Typ jednorazowy, którego wartość zmiennej po prawej stronie nie pokazuje jednoznacznie typu. Pozbycie się IDisposable można łatwo zapomnieć o

Przykład:

// 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.

Nie ma żadnej różnicy technicznej, jeśli używasz var, typ jest sugerowany przez kompilator. Jeśli masz taki kod:

var x = 1;

X jest implikowane jako int i żadne inne wartości nie mogą być przypisane do niego.

Słowo kluczowe var jest przydatne, jeśli zmienisz typ zmiennej; wtedy musisz dokonać tylko jednej zmiany zamiast dwóch:

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

Słowo kluczowe var zostało wprowadzone w C # 3.0-pozwala nam zapomnieć o jawnym określeniu naszego typu.

Nie ma żadnej różnicy, czy używasz

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

Lub

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

Poza czystą czytelnością i mniejszą szansą na błąd.

Wydaje się to banalnym przykładem, ale powiedzmy, że następujące słowa mogą pomóc w zrozumieniu:

var myInt = 23;

Zwraca typ int, natomiast

var myInt = "23";

Zwraca typ string.

MSDN numer referencyjny

Podanie jawnego typu obiektu jest w jakiś sposób zbędne. Nawet przetłumaczone na język angielski, brzmi to zbędnie: "umieść obiekt typu X w zmiennej typu X" vs "umieść obiekt typu X w zmiennej".

Jednakże użycie ' var ' ma swoje ograniczenia . Zapobiega poniższemu użyciu polimorfizmu , który jest czystym pięknem :

Załóżmy, że pies rozszerza Zwierzę; Kot rozszerza hierarchię klas zwierząt:

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

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

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

Ten sam kod, z X zadeklarowanym przez 'var' nie skompiluje.

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

W każdym razie, wracając do pierwotnego pytania, nie używam Resharper, ale zakładam, że to jest wystarczająco inteligentne, aby wykryć, kiedy nie używać 'var'. :-)

'var' dodaje do kodu rodzaj "dynamicznego" elementu (chociaż kod pozostaje oczywiście ściśle wpisany). Radzę nie używać go w przypadkach, gdy Typ nie jest jasny. Rozważ ten przykład:

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

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

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

Jeśli zwracany typ GetTheObjectFromDatabase () zostanie zmieniony z Typu A na B, nie zauważymy, ponieważ obie klasy implementują DoSomething (). Kod może jednak teraz zrobić coś zupełnie innego.

Następujące użycie var powinno być zawsze w porządku:

var abc = new Something();

Dla tych, którzy nie lubią ciągłego używania "var", możesz również powstrzymać ReSharper przed domyślnym ustawieniem var podczas "introduce variable". To było coś, co frustrowało mnie przez długi czas, zawsze było domyślne dla var, a ja zmieniałem go za każdym razem.

Te ustawienia znajdują się w sekcji Edycja kodu > C# > Styl kodu

Nie ma żadnej różnicy technicznej(jak zauważył eWolf). Możesz użyć jednego lub drugiego, wygenerowany kod CLR będzie wyglądał tak samo.

Moim zdaniem główną korzyścią jest to, że zmusza to do używania lepszego nazewnictwa zmiennych. W twoim przykładzie 'foo' jest dość słabym wyborem dla nazwy zmiennej.

Według JetBrains (autora ReSharper), domyślnie zachęcają do używania var.

Z ich strony internetowej :

Używanie domyślnych zmiennych lokalnych (znanych również jako słowo kluczowe var) wprowadzone w C# 3.0 stało się dość popularne, ponieważ poprawia czytelność w wielu scenariuszach. Domyślnie ReSharper zachęca również do używania słowa kluczowego var, ale Preferencje jego użycia są elastycznie konfigurowalne - na przykład możesz zdecydować się na użycie jawnych typów w konkretnych przypadkach lub wszędzie i ReSharper pomoże Ci wyegzekwować swoje preferencje.