Почему 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и я все еще могу получить доступ к методам дочерних классов.

Помимо этого, улучшение читабельности является важным моментом, но, как говорили другие, не следует злоупотреблять var, поэтому я думаю, что отключение подсказки в Resharper - это абсолютно нормально.

'var' означает быть ясным

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

Так же, как если бы вы писали историю, нет однозначного правильного ответа. Но давайте посмотрим на некоторые примеры этого на простом английском языке.

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

Кто пошел другим путем? Джейк или Билл? В этом случае использование имен «Jake» и «Bill» похоже на использование имени типа. И «он», и «он» - это все равно, что использовать 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 и Вар

Я вижу много правильных ответов, но пропускаю полный.

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

Сначала я попытался прокомментировать другие посты, чтобы добавить, где их устанавливать, но у меня не было репутации. Судя по всему, у меня также не было репутации, чтобы опубликовать свой скриншот настроек.

Я объясню, как туда добраться.

В Visual Studio> Главное меню> Resharper> Параметры> Редактирование кода> 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 # Coding Conventions

когда тип переменной очевиден с правой стороны присваивания, или когда точный тип не важен

так что, вероятно, поэтому в ReSharper этот совет включен по умолчанию. Они также предоставляют некоторые случаи, когда это не улучшит читабельность прямо в том же документе.

ReSharper рекомендует, varпотому что это имеет тенденцию снимать помехи с создания объектов.

Сравните эти два примера:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Это просто стенография, которая должна быть легче читаемой.

Я думаю, что это нормально, когда вы создаете новые объекты явно с "новым". Однако в вашем примере это может быть неочевидно, если классы не были названы правильно.

Кстати, ReSharper проводит различие между «вы можете применить это предложение к своему коду» и «ваш код не работает, хотите, чтобы я его исправил?». varКлючевое слово в предложении категории, наряду с такими вещами , как «инвертировать , если уменьшить вложенности»; Вы не должны следовать этому.

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

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

Вар потрясающий! Я сталкивался со многими разработчиками, у которых сложилось впечатление, что они 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немного расплывчатым, это действительно поощрять имя более desciptive переменной , а не давая Говори типа для себя.

Менее код изменяется - если изменяется тип возврата вызова метода. Вам нужно только изменить вызов метода, а не каждое место, где он используется.

Анонимные типы - анонимные типы - действительно мощная концепция, особенно в таких областях, как частичные ресурсы 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' имеет свои ограничения . Это предотвращает использование ниже полиморфизма, который является чистой красотой :

Предположим, собака расширяет животное; Cat расширяет иерархию классов Animal:

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

Кроме этих сценариев, я не вижу никакой выгоды, которую можно получить с помощью var, но я могу вспомнить некоторые сценарии, в которых это может быть вредно:

Например, одноразовый тип, значение переменной в правой части которого не совсем ясно показывает тип. Утилизация IDisposable может быть легко забыта о

Пример:

// 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 (). Код, однако, теперь может фактически сделать что-то совершенно другое.

Это может быть так же тонко, как и запись разных вещей в журнал, так что вы можете не заметить, что слишком поздно.

Следующее использование var всегда должно быть хорошо:

var abc = new Something();

Для тех, кому не нравится постоянное использование «var», вы также можете остановить ReSharper от установки значения по умолчанию для var при выполнении «вводить переменную». Это было чем-то, что меня расстраивало в течение долгого времени, это всегда было по умолчанию, и я менял его каждый раз.

Эти настройки находятся под Редактирование кода> C #> Стиль кода

Технических отличий нет (как указал eWolf). Вы можете использовать один или другой, сгенерированный код CLR будет выглядеть одинаково.

На мой взгляд, главное преимущество заключается в том, что это заставляет вас использовать лучшие имена переменных. В вашем примере 'foo' - довольно плохой выбор для имени переменной.

По словам JetBrains (автора ReSharper), они поощряют использование var по умолчанию.

С их сайта :

Использование неявно типизированных локальных переменных (также известных как varключевое слово), представленных в C # 3.0, стало довольно популярным, поскольку это улучшает читабельность во многих сценариях. По умолчанию ReSharper также поощряет использование varключевого слова, но предпочтения его использования гибко настраиваются - например, вы можете выбрать использование явных типов в определенных случаях или везде, и ReSharper поможет вам реализовать ваши предпочтения.