Почему ReSharper хочет использовать 'var' для всего?


214

Я только начал использовать 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, поэтому мне бы очень хотелось понять, что происходит и приносит ли это пользу или нет.



27
Я думал об этом некоторое время, и пришел к выводу, что я должен всегда использовать var, даже когда тип не совсем очевиден! причина в том, что это вынуждает меня выбирать наиболее описательное имя, которое я могу придумать, и в конечном итоге это делает код намного, намного более читабельным. В конечном итоге это также помогает отделить логику от реализации. Конечно, это только мое мнение, я надеюсь, что это кому-нибудь поможет;).
MasterMastic

Ответы:


189

Одна из причин - улучшенная читаемость. Что лучше?

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

или

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

260
Я бы сказал, первый. Легче увидеть, что происходит!
Mongus Pong

104
Грибок: Вам нравится? Вам нравится Redundant Text Redundant Text? : D
Марк Симпсон

73
Быть явным, на мой взгляд, более ясно. Использование var для многих создает головную боль в некоторых сценариях.
user1231231412

172
Я ненавижу, когда разработчики используют varдля всего - я делаю много-много обзоров кода с использованием TFS (различий в сети), и это делает мою работу чрезвычайно трудной: то есть var items = GetSomeItems();против IDataReader dr = GetSomeItems();пропущенного использования оператора в обоих случаях, но мне легче поймать при использовании IDataReaderпротив var.
Крис Гесслер

17
если вы хороший разработчик, пишущий хороший код, и используете библиотеку, например Resharper, то вам не нужно знать явный тип, с которым вы имеете дело. Так же, как когда вы используете интерфейсы для объявления контракта, а не конкретный класс, var позволяет вам сказать, что вам все равно, что такое возвращаемый тип, вам важно только то, что он делает, и используя переменные с именами вместе с помощью помощников intelli-sense & resharper / VS (таких как CTRL + CLICK для перехода к определению) вы доберетесь до 99% пути. Кроме того, использование var означает, что мне не нужно переписывать базу кода, если я изменяю тип возвращаемого метода.
Джошуа Баркер

286

ReSharper предлагает явно злоупотреблять ключевым словом var. Вы можете использовать его там, где тип очевиден:

var obj = new SomeObject();

Если тип неочевиден, лучше написать его:

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

36
Чтобы играть в защиту дьяволов, возможно, если тип не понятен из метода или имени переменной, это указывает на проблему с именованием более, чем чрезмерное использование var. Я согласен в принципе, хотя, var следует использовать только тогда, когда это не убирает ясности.
Мэтт Бриггс

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

18
@Jaco: +1, но стоит упомянуть, что информацию о типе не рекомендуется указывать в имени переменной. Например, венгерская запись не считается хорошей практикой.
Роман Бойко

8
Вопрос о том, являются ли настройки ReSharper по умолчанию чрезмерным, varзависит от мнения, а не от «чёткой» той или иной вещи. Я предпочитаю не печатать то, что компилятор может понять сам. Мне нравится вывод типа C #, и я часто хотел бы, чтобы это было так же хорошо, как вывод типа F #. Если бы я мог, я бы пропустил явные типы из параметров метода и возвращаемых типов, как это является нормой в F #. Не все согласны, конечно.
Джоэл Мюллер

15
@AnonymousType: Вы все еще не понимаете суть. Вы сказали, что имена методов должны всегда отражать намерение метода, но даже если они это делают, это не означает, что имя указывает тип возвращаемого значения. Метод для чтения из Streamобъекта, например, называется Read, а не ReadAndReturnNumberOfBytesAsInt32.
Гуффа

99

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

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


11
Я думал, что ReSharper должен был быть довольно умным; Разве это не должно быть достаточно умно, чтобы знать, когда результирующий тип очевиден (например, что-нибудь с новым ключевым словом), а когда он не очевиден?
Рассерженная шлюха

3
Ну, я не знаю особенностей этой функции, но я точно знаю, что меня ошеломило количество предложений, которые она дала; И я использую varдовольно часто тоже.
Брайан Менард

5
Я обнаружил, что когда вы всегда используете var (как, например, советует resharper), это заставляет вас правильно называть переменные.
Sauleil

Можете ли вы отключить предложение?
Крис С

@AngeDeLaMort: дело в том, что это заставляет вас использовать неправильные имена, например var methodXYResultIntArray. Это против всех стандартов кодирования и менее лаконично, чем int[] methodXYResult. Если вы хотите вернуть byte[]метод из метода в будущем, все ваши имена переменных будут неправильными. С явными типами вы могли бы очень легко это изменить. Есть причины использовать var, например, с Dictionary<string, List<SomeType<int>>>. Но если полное имя-типа не слишком длинное, и вы не используете newсправа (или явное приведение), резарпер не должен предлагать это.
Тим

69

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


5
ИМХО ваши примеры на самом деле являются вескими причинами для использования var, это заставит вас писать достойные имена методов. GetNumber() -but what type?- ну а тебе какое дело? Если это так важно знать, вызовите метод GetNumberAsDouble(), тогда это так же ясно и будет работать, если у вас есть один метод, возвращающий stringи один возвращающий double.
nicodemus13

10
@ nicodemus13 Вы обычно знаете, когда вам небезразличен тип возвращаемого значения функции, когда вы фактически используете возвращаемое значение, а не когда пишете саму функцию. Предложенная вами схема именования может привести к злоупотреблениям, таким как GetResultsAsIEnumerableOfDouble, и все, что она делает, это смещает информацию о типе, которую вы удалили, с левой стороны назначения, используя var, на правую сторону assignemnt.
Эрик

var value2 = Math.Abs ​​(-3); // Очевидно, числовой тип данных. Извините, я совершенно не согласен с этим, учитывая, что метод Abs имеет 7 перегрузок, которые не дают ничего, кроме мрака при взгляде на него, imo
s1cart3r

var также может привести к незначительным логическим ошибкам, таким как: var counter = "0"; когда то, что вы хотите, является целым числом.
Аланиан

42

В ReSharper (8.02, но, вероятно, в других версиях) параметр для предложения «Использовать объявление неявно типизированной локальной переменной» может быть скорректирован в соответствии с вашими предпочтениями , каким бы он ни был, сначала открыв меню параметров для ReSharper:

Меню параметров ReSharper

Затем в разделе «Проверка кода» настройте «Уровень проверки» выбранного вами языка, в моем случае c #:

Отключить неявно типизированное предложение локальной переменной

Как вы можете видеть, есть варианты, чтобы настроить все предложения, которые делает ReSharper. Надеюсь, это поможет кому-то вроде меня, у которого уже есть стратегия использования 'var', и он просто хочет, чтобы ReSharper уважал ее :)


Это отвечает на другой вопрос, который вообще не задавался.
Карлес

9
Но это актуально для многих, кто ищет это, когда попадает сюда. +1
Ори Нахум

24

Я удивлен, что никто не упомянул, что также легче изменить тип создаваемого объекта, потому что

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

это форма повторения . Если я хочу перейти AVeryLongTypeNameв один из его производных классов, мне нужно изменить его только один раз при использовании, varи я все еще могу получить доступ к методам дочерних классов.

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


Очень полезно при вызове заводских методов, а не «новых»
Ян Рингроз

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

24

'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ключевое слово, оно более полно для меня большую часть времени. Но я также склоняюсь называть свои переменные после типа, поэтому я не теряю никакой информации.

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


1
Мне нравится этот ответ больше всего, потому что я ничего не имею против, varпока я знаю, что это такое, читая эту строку. Если я понятия не имею, что возвращает метод из другого Решения, использующего другую модель предметной области, я, скорее, определил этот тип явно, что значительно облегчает его чтение. +1
Петр Кула

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

18

Мне это тоже не понравилось.

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

Важно помнить, что ReSharper настроен на любые стандарты кодирования, которые вы хотите.

Изменить: ReSharper и Вар


13
После года или около того сопротивления я почти всегда использую var сейчас.
LiamB

15

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

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

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

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

В Visual Studio> Главное меню> Resharper> Параметры> Редактирование кода> C #> Стиль кода> Использование переменных в объявлениях

  • Для встроенных типов Используйте явный тип
  • Для простых типов используйте 'var', когда это очевидно
  • В другом месте Use'var '

введите описание изображения здесь

Справочная документация ReSharper: Стиль синтаксиса кода: неявная / явная типизация (ключевое слово 'var') - настройка параметров использования ключевого слова 'var'


Это должно быть помечено как правильный ответ вне вар дебатов, это сбалансированный подход
Брайан Огден

Не могли бы вы привести пример того, как определяется «где очевидно»?
катится


13

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

  • Вы объявляя примитивный тип (т.е. 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();

Я хотел бы не согласиться, string myStr = "foo";очевидно, что это строка. Я бы поместил все ваши примеры в категорию var ... и объявления, возвращаемые методом для использования типа explicity. Но в конце концов, то, что вы и ваша команда чувствуете лучше для конкретного проекта.
Дин Михан,

12

Я просто хотел бы отметить, что использование "var" рекомендуется в C # Coding Conventions

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

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


Это замечательно, когда вы знаете, что тип исходит System.Diagnostics.PerformanceCounter() - вы можете легко узнать его счетчик производительности из встроенного класса диагностики. Но какой тип возвращается здесь? var thingyMaBob = GetThatSpecialThing(18,null,(MyEnum)2)? Понятия тактики нет, особенно если в вашем решении более 100 проектов.
Петр Кула

«Рекомендуется, когда тип переменной очевиден», и «Они также предоставляют некоторые случаи, когда это не улучшит читабельность прямо в том же документе». Честно говоря, я думаю, что я упустил вашу точку зрения. Мой ответ говорит то же, что и вы.
Хосе

6

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

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

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

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

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


6

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

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



4

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


2

Технических отличий нет, если вы используете var, тип подразумевается компилятором. Если у вас есть такой код:

var x = 1;

x подразумевается как int, и никакие другие значения не могут быть ему присвоены.

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

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

1
@AlexKamburov код 10 строк ниже сломается в любом случае, не имеет отношения к var.
user3285954

1
@ user3285954 В некоторых случаях var может скрыть проблему, и тогда все может стать ужасным. Проблема не в написании кода, а в удобстве обслуживания. Некоторые утверждают, что с var это чище, но иногда я вижу это как запутывание. Это близко к религиозной дискуссии. brad-smith.info/blog/archives/336 Я лично использую var только для операторов Linq и других мест, где объявление типа действительно многословно. Я думаю, что var - хорошее дополнение, и люди должны смотреть комментарии Андерса Хейлсберга о причинах его введения.
Алексей Камбуров

2

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


2

Указание явного типа объекта как-то излишне. Даже переведенный на английский, звучит излишне: «поместите объект типа 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'. :-)


4
Ненужное литье (с as) чисто ужасно. Вы превращаете ошибки компиляции в ошибки времени выполнения, если у вас есть что-то вроде Animal x = new Cat(); DoStuffWithDog(x as Dog); Зачем использовать x? Dog x = new Dog (), Cat y = new Cat (), бум больше не допускает двусмысленности.
Марк Совул

приведение (с «как» или нет) может привести к ошибке во время выполнения. Что такого ужасного в кастинге, когда ты знаешь, что делаешь? Зачем использовать х? Пример здесь является иллюстративным. Цель этого примера - показать, как использование var может привести к ограничениям, если ссылка должна быть полиморфной.
xtrem

5
Нет, не может: полиморфизм противоположен тому, что здесь происходит. Это пытается передать объекты типа Animalв методы, которые принимают Dogи Cat. Полиморфизм обратный: так что вы можете передавать объекты типа Dogи Catв методе , который принимает Animal, например void Walk(Animal a): Walk(new Cat()),Walk(new Dog())
Марк Sowul

Вы не должны использовать переменные таким образом, это приводит к очень неприятным ошибкам. В коротких методах это не так очевидно, но когда у вас 15-20 строк кода, вы забудете, что такое x. Не ленитесь: var dog = new Dog (); DoStuff (собака); var cat = new Cat (); DoStuff (кошка);
user3285954

2
Нет борьбы. У меня нет чувств ни к каким способам объявления переменных (неявных или явных). Я фактически использую по крайней мере один из каждых большинства дней. Я просто подчеркиваю, что когда вы выбрали неявный (var) метод, компилятор определит для вас наиболее узкий тип. Который не всегда может быть тем, что вы хотите. Вот и все.
xtrem

2

На мой взгляд, 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.

1

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

1

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

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

введите описание изображения здесь


0

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

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


0

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

С их сайта :

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


Где я могу настроить, когда требовать явного объявления типа?
user764754
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.