Чому ReSharper хоче використовувати "var" для всього?

Я тільки почав використовувати ReSharper з Visual Studio (після багатьох рекомендацій щодо SO). Щоб спробувати це, я відкрив недавній проект ASP.NET MVC. Однією з перших і найчастіших речей, які я помітив, пропонуючи змінити більшість / всі мої явні декларації varзамість цього. Наприклад:

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

і так далі, навіть прості типи , такі як int, boolі т.д.

Чому це рекомендується? Я не походжу з інформатики чи .NET фону, недавно "потрапивши" в розробку .NET, тому мені дуже хотілося б зрозуміти, що відбувається і користь це чи ні.

Однією з причин є поліпшення читабельності. Який краще?

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

або

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

Що пропонує ReSharper - це явно надмірне використання ключового слова var. Ви можете використовувати його там, де тип очевидний:

var obj = new SomeObject();

Якщо тип не очевидний, скоріше випишіть його:

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

Я особисто вважаю за краще вимкнути цю пропозицію. Використання varчасто може покращити читабельність; але, як ви згадали, іноді це зменшує (за допомогою простих типів, або коли отриманий тип є неясним ).

Я вважаю за краще вибирати, коли використовую, varа коли ні. Але знову ж таки, це тільки я.

varможе збільшити читабельність коду, зменшивши при цьому негайне розуміння коду. Так само, це може знизити читабельність коду для інших ситуацій. Іноді використання його нейтральне. Міра читабельності розуміння не пропорційна, а залежить від ситуації. Іноді обидва разом збільшуються або зменшуються.

Фактор полягає в тому var, до чого застосовується і наскільки добре ціль підтримує негайне затуплення свого типу даних для читача, або якщо інформація про його тип потрібна для розуміння програми, що знаходиться в руці.

Наприклад, неправильне називання може призвести до varзниження розуміння коду. Не varв цьому помилка:

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

Іноді не має сенсу використовувати varдля простих типів даних, коли код є більш читабельним за його відсутності:

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

Іноді varможе бути корисно приховати інформацію про тип даних, яка вам не обов'язково бачити, щоб побачити складності:

    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; 

Ви повинні використовувати, varколи присутній анонімний тип, оскільки немає імені типу, щоб викликати його за:

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

Якщо у вас є Visual Studio Intellisense, який надає інформацію про тип, незважаючи на це var, вам потрібно менше покладатися на своє розуміння через суворе читання коду без допомоги. Напевно, розумно припустити, що не кожен може мати або використовувати Intellisense.

Підсумовуючи наведені вище приклади, я б припустив, що застосування карт-бланшу varне є хорошою ідеєю, оскільки більшість речей найкраще робити в міру та виходячи з обставин, як показано тут.

Чому Resharper використовує його за замовчуванням? Я б запропонував для зручності, оскільки він не може розібратися у нюансах ситуацій, щоб вирішити, коли краще не використовувати його.

У ReSharper (8.02, але, ймовірно, в інших версіях) опцію пропозиції "Використовувати неявно набране місцеве оголошення змінної" можна відкоригувати відповідно до ваших уподобань , спочатку відкривши меню параметрів для ReSharper:

Потім у розділі "Інспекція коду", скоригувавши "Інтенсивність перевірки" обраної вами мови, у моєму випадку c #:

Як бачите, є варіанти коригування всіх пропозицій, які вносить ReSharper. Сподіваємось, це допомагає комусь, як я, хто вже має стратегію використання 'var' і просто хоче, щоб ReSharper це дотримувався :)

Я здивований, що ніхто не згадав, що також простіше змінити тип об'єкта, оскільки він є

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

є формою повторення . Якщо я хочу перейти AVeryLongTypeNameна один із похідних класів, мені потрібно змінити це лише один раз, коли я використовую, varі все ще можу отримати доступ до методів дочірніх класів.

Крім цього, поліпшення читабельності є важливим моментом, але, як говорили інші, вар не слід надмірно використовувати, тому я думаю, що вимкнути підказку в Resharper абсолютно нормально.

'var' - це зрозуміти

Основна дискусія щодо того, використовувати varключове слово чи ні, полягає в тому, наскільки читабельний код вам та іншим розробникам.

Так само, як ніби ви писали історію, немає остаточної правильної відповіді. Але давайте розглянемо кілька прикладів цього простою англійською мовою.

Джейк привітався з Біллом. Він йому не сподобався, тому він повернувся і пішов іншим шляхом.

Хто пішов іншим шляхом? Джейк чи Білл? У цьому випадку використовувати імена "Джейк" і "Білл" - це як використовувати ім'я типу. І "Він" і "Він" - це як використання varключового слова. У цьому випадку це може допомогти бути більш конкретним. Далі, наприклад, набагато зрозуміліше.

Джейк привітався з Біллом. Джейку не сподобався Білл, тому він повернувся і пішов іншим шляхом.

У цьому випадку більш конкретніше зробило речення більш зрозумілим. Але це не завжди буде так. У деяких випадках конкретність ускладнює читання.

Біллу подобаються книги, тому Білл пішов до бібліотеки, а Білл вийняв книгу, яку Білл завжди любив.

У цьому випадку було б простіше прочитати речення, якби ми використовували "він", а в деяких випадках все своє ім'я випускали разом, що є еквівалентом використання varключового слова.

Біллу подобаються книги, тому він пішов до бібліотеки і дістав книгу, яка йому завжди подобалася.

Ці приклади висвітлюють суть, але вони не розповідають усієї історії. У тих прикладах був лише один спосіб посилатися на людину. Або за допомогою їх імені, або за допомогою більш загального терміна, як "він" і "він".

У випадку з кодом у нас є 3 способи, які допоможуть додати чіткість. Тип, назва змінної та призначення. Візьмемо, наприклад, цей рядок коду:

Person p = GetPerson();

Тепер стає питання, чи достатньо інформації в цьому рядку коду, щоб допомогти вам зрозуміти, що відбувається?

Що з наступного рядка коду? Ви все ще знаєте, що pозначає в даному випадку:

var p = GetPerson();

Як щодо тепер:

var p = Get();

Або зараз:

var person = Get();

Або цей:

var t = GetPerson();

Або це:

var u = Person.Get();

Від того, чи varпрацює ключове слово у визначеному сценарії, багато в чому залежить від контексту коду, наприклад, як називаються змінні, класи та методи. Це також залежить від складності коду та решти коду, що його оточує.

Особисто мені подобається використовувати varключове слово, яке для мене більш вичерпне . Але я також схильний називати свої змінні за типом, щоб я не втрачав жодної інформації.

Інакше кажучи, залежно від контексту, в якому я роблю винятки, така природа будь-чого складного, а програмне забезпечення - це нічого, якщо не складне.

Мені це також не сподобалось.

Я не хочу, щоб це переросло в дебати щодо використання var, воно має своє використання, але не повинно використовуватися скрізь.

Головне, що потрібно пам’ятати, це те, що ReSharper налаштований на будь-які стандарти кодування, які ви хочете.

Редагувати: ReSharper та var

Я бачу багато правильних відповідей, але повну не вистачає.

Це правда, що ReSharper varза замовчуванням перестарається . Я думаю, що більшість людей погодиться з цим. Також легше читати, коли varвикористовується, і тип очевидний, наприклад, коли ви використовуєте newоператор. Я побачив один пост, який показав, як оновити суворість перевірки, щоб показати лише підказки для використання var.

Я спробував спочатку прокоментувати інші пости, щоб додати, де їх встановити, але репутації не мав. Мабуть, я також не мав репутації розміщувати скріншот налаштувань.

Я поясню, як туди дістатися.

У Visual Studio> Головне меню> Перезапуск> Опції> Редагування коду> C #> Стиль коду> Використання змін у деклараціях

• Для вбудованих типів Використовуйте явний тип
• Для простих типів Використовуйте "var", коли це очевидно
• В іншому місці Use'var '

Довідкова документація ReSharper: Стиль синтаксису коду: Неявне / явне введення тексту (ключове слово "var") - Налаштування параметрів використання ключового слова "var"

Моє правило таке:

• Ви оголошуючи примітивний тип (тобто byte, char, string, int[], double?, decimalі т.д.)? -> Використовуйте тип:

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

• Ви оголошуючи складний тип (тобто List<T>, Dictionary<T, T>, MyObj)? -> Використання var:

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

Я просто хотів би зазначити, що використання "var" рекомендується в Конвенціях про кодування C #

коли тип змінної очевидний з правого боку призначення або коли точний тип не важливий

тому, ймовірно, тому підказка у ReSharper за замовчуванням увімкнена. Вони також наводять деякі випадки, коли це не поліпшить читабельність прямо в тому ж документі.

ReSharper рекомендує, varоскільки він має тенденцію до безладного створення об'єктів.

Порівняйте ці два приклади:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Це просто скорочення, яке має бути легше читати.

Я думаю, це добре, коли ви створюєте нові об’єкти явно за допомогою "нового". У вашому прикладі, однак, це може бути не очевидно, якщо класи не були названі належним чином.

До речі, ReSharper розрізняє "ви можете застосувати цю пропозицію до вашого коду" та "ваш код порушений, хочете, щоб я це виправити?". varКлючове слово в реченні категорії, поряд з такими речами , як «інвертувати , якщо зменшити вкладеності»; вам не доведеться слідувати цьому.

Ви можете налаштувати, як дратує кожне його сповіщення через діалогове вікно Параметри або безпосередньо через спливаюче меню для цього сповіщення. Ви можете зменшити кількість речей, як varпропозиція, щоб вони були менш помітними, або ви можете оновити такі речі, як сповіщення "метод використання розширення", щоб воно відображалося як фактична помилка.

varОсобливість .Net 3.0 тільки тип логічний висновок , який є безпечним і типу часто робить легше читати ваш код. Але вам цього не потрібно, і ви можете вимкнути цю рекомендацію заново, якщо хочете.

Вар дивовижний! Я стикався з багатьма розробниками, які опиняються під враженням, що varпов'язане з динамічним типом, це не так. Він все ще статично набраний, це просто вирішив компілятор.

Ось кілька дивовижних позитивних можливостей використання var

Менше введення var коротше і простіше для читання, наприклад,

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

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

Більш описові назви змінних - похмурі, але я думаю, що важливо, щоб varтут просвічувала текуча природа . Як varце трохи розпливчасто, це дійсно заохочує більш дескриптивну назву змінної, а не дозволяти типу говорити сам за себе.

Менше змін коду - якщо тип повернення виклику методу змінюється. Вам потрібно лише змінити виклик методу, а не кожне місце, де воно використовується.

Анонімні типи - анонімні типи - це дійсно потужне поняття, особливо в таких сферах, як часткові ресурси WebApi . Без var їх не можна використовувати.

Однак іноді корисно експліцитно оголошувати типи, і я вважаю це найбільш корисним у примітивах чи структурах. Наприклад, я не вважаю цей синтаксис дуже корисним:

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

}

проти

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

}

Все зводиться до особистих уподобань, але використання varсправді пришвидшить ваш розвиток та відкриє цілий світ доброти анонімного типу.

Немає технічної різниці, якщо ви використовуєте var, тип має на увазі компілятор. Якщо у вас є такий код:

var x = 1;

x мається на увазі як int, і інші значення не можуть бути призначені йому.

Ключове слово var корисне, якщо ви зміните тип змінної; тоді вам доведеться внести лише одну зміну замість двох:

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

varКлючове слово було введено в C # 3.0 - це дозволяє нам забути про надання нашого типу явно.

Немає реальної різниці в тому, чи використовуєте ви

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

або

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

крім чистої читабельності та менше шансів на помилку.

Здається, що це клішений приклад, але скажіть, що наступне може допомогти вам зрозуміти:

var myInt = 23;

повертає intтип, тоді як

var myInt = "23";

повертає stringтип.

Посилання MSDN

Вказання явного типу об'єкта якимось чином не зайве. Навіть у перекладі англійською мовою, це звучить зайвим: "поставте об'єкт типу X у змінну типу X" проти "Поставте об'єкт типу X у змінну".

Однак використання 'var' має свої обмеження . Це перешкоджає використанню поліморфізму, який є чистою красою :

Припустимо, собака розширює тварину; Кіт розширює ієрархію класів тварин:

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

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

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

Той самий код з x, оголошеним 'var' , не буде компілюватися .

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

У будь-якому випадку, повертаючись до початкового питання, я не використовую Resharper, але я вважаю, що це досить розумно, щоб визначити, коли не використовувати 'var'. :-)

На мій погляд, його varслід застосовувати лише тоді, коли буде відразу зрозуміло, що таке тип при визначенні значення змінної.

Приклад:

var s = "string value";

Очевидно, що sце string.

Я вважаю, що це також доречно, коли ім'я типу змінної дуже складне.

Приклад:

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

Окрім цих сценаріїв, я не бачу, щоб будь-який GAIN був зроблений за допомогою var, але я можу придумати деякі сценарії, в яких це може бути згубним:

Наприклад, одноразовий тип, значення правого змінного значення якого чітко не відображає тип. Утилізацію ідентифікатора можна легко забути

Приклад:

// 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' додає у свій код якийсь "динамічний" елемент (хоча код залишається, звичайно, строго набраним). Я раджу проти його використання у випадках, коли тип не зрозумілий. Розглянемо цей приклад:

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

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

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

Якщо тип повернення GetTheObjectFromDatabase () буде змінено з типу A на B, ми не помітимо, оскільки обидва класи реалізують DoSomething (). Однак код тепер може насправді робити щось зовсім інше.

Це може бути настільки тонким, як обидва записування різних матеріалів у журнал, тому ви можете не помітити unitl, що вже пізно.

Наступне використання var завжди має бути добре:

var abc = new Something();

Для тих, хто не любить постійне використання "var", ви також можете зупинити ReSharper від дефолту до var, виконуючи "ввести змінну". Це щось мене довго засмучувало, воно завжди дефолтувало до вару, і я щоразу міняв це.

Ці налаштування знаходяться в розділі Редагування коду> C #> Стиль коду

Технічної різниці немає (як вказував eWolf). Можна використовувати той чи інший, згенерований код CLR буде виглядати однаково.

На мою думку, головна перевага полягає в тому, що це, як правило, змушує вас використовувати кращі імена змінних. У вашому прикладі "foo" - це досить поганий вибір для назви змінної.

За словами JetBrains (автора ReSharper), вони заохочують використання var за замовчуванням.

З їх веб-сайту :

Використання імпліцитно набраних локальних змінних (також відомих як varключове слово), введених у C # 3.0, стало досить популярним, оскільки покращує читабельність у багатьох сценаріях. За замовчуванням ReSharper також рекомендує використовувати varключове слово, але налаштування його використання можна легко налаштувати - наприклад, ви можете вибрати явні типи в конкретних випадках або скрізь, і ReSharper допоможе вам застосувати свої налаштування.