Использование ключевого слова var в C #

Помимо проблем с читабельностью, существует одна реальная проблема с использованием 'var'. Когда переменные используются для определения переменных, которые присваиваются позже в коде, это может привести к поломке кода, если тип выражения, используемого для инициализации переменной, изменится на более узкий тип. Обычно безопасно рефакторить метод, чтобы он возвращал более узкий тип, чем раньше: например, заменить возвращаемый тип 'Object' на какой-нибудь класс 'Foo'. Но если есть переменная, тип которой определяется на основе метода, то изменение возвращаемого типа будет означать, что этой переменной уже нельзя присвоить объект, не являющийся Foo:

var x = getFoo(); // Originally declared to return Object
x = getNonFoo();

Так, в данном примере изменение возвращаемого типа getFoo сделает присвоение из getNonFoo незаконным.

Это не такая уж большая проблема, если getFoo и все его использования находятся в одном проекте, но если getFoo находится в библиотеке для использования внешними проектами, вы больше не можете быть уверены, что сужение типа возврата не сломает код некоторых пользователей, если они используют 'var' подобным образом.

Именно по этой причине, когда мы добавили аналогичную функцию определения типа в язык программирования Curl (в Curl она называется 'def'), мы предотвратили присваивание переменным, определенным с помощью этого синтаксиса.

Прибыв немного позже на этом обсуждении, но я просто хотел бы добавить мысль.

Всем тем, кто против вывода типа (потому что это то, о чем мы действительно говорим здесь), а как насчет лямбда-выражений? Если вы настаиваете всегда объявлять типы явно (кроме анонимных типов), что вы делаете с лямбдами? Как аргумент «Не заставляй меня использовать указатель мыши» применяется к var, но не к лямбдам?

ОБНОВЛЕНИЕ

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

VS2008 w/resharper 4.1 имеет корректный ввод в подсказке, когда Вы нависаете над "var", таким образом, я думаю, что это должно смочь найти это при поиске всех использований класса.

Еще не протестировали это, это делает это все же все же.

Я не думаю, что var per say - ужасная языковая функция, поскольку Я использую его ежедневно с кодом, подобным тому, что описал Джефф Йейтс. На самом деле, почти каждый раз я использую var потому, что обобщения могут сделать код очень многословным. Я живу многословным кодом, но дженерики заходят слишком далеко.

Тем не менее, я (очевидно ...) думаю, что var созрел для злоупотреблений. Если код достигнет 20+ строк в методе с заваленными варами, вы быстро превратите обслуживание в кошмар. Кроме того, var в учебном пособии невероятно интуитивно понятен и, как правило, в моих книгах запрещен.

С другой стороны, var - это «простая» функция, которую новые программисты собираются ухватить и полюбить. Затем, в течение нескольких минут / часов / дней, когда они начинают достигать пределов, они сталкиваются с серьезным препятствием. «Почему я не могу вернуть var из функций?» Такой вопрос. Кроме того, добавление псевдодинамического типа к строго типизированному языку может легко сбить с толку нового разработчика. В долгосрочной перспективе, я думаю, ключевое слово var действительно затруднит изучение C # для начинающих программистов.

Тем не менее, как опытный программист, я использую var в основном при работе с обобщенными типами (и, очевидно, с анонимными типами). Я придерживаюсь своей цитаты и верю, что var будет одной из наиболее часто используемых функций C #.

Тем не менее, как опытный программист, я использую var в основном при работе с обобщенными типами (и, очевидно, с анонимными типами). Я придерживаюсь своей цитаты и верю, что var будет одной из наиболее часто используемых функций C #.

Тем не менее, как опытный программист, я использую var в основном при работе с обобщенными типами (и, очевидно, с анонимными типами). Я придерживаюсь своей цитаты и верю, что var будет одной из наиболее часто используемых функций C #.

var отлично подходит, когда вы не хотите повторяться. Например, вчера мне нужна была структура данных, похожая на эту. Какое представление вы предпочитаете?

Dictionary<string, Dictionary<string, List<MyNewType>>> collection = new Dictionary<string, Dictionary<string, List<MyNewType>>>();

или

var collection = new Dictionary<string, Dictionary<string, List<MyNewType>>>();

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

var value= 5;

, когда я мог бы просто написать реальный тип и устранить любую двусмысленность в том, как 5 должен быть представлен.

double value = 5;

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

Кроме того, он упрощает изменение типов переменных.

В зависимости от того, каким-то образом это делает код «чище», но согласитесь, что это делает его более нечитаемым. ..

From Essential LINQ:

It is best not to explicitly declare the type of a range variable unless absolutely necessary. For instance, the following code compiles cleanly, but the type could have been inferred by the compiler without a formal declaration:

List<string> list = new List<string> { "LINQ", "query", "adventure" };
var query = from string word in list
      where word.Contains("r")
      orderby word ascending
      select word;

Explicitly declaring the type of a range variable forces a behind-the-scenes call to the LINQ Cast operator. This call may have unintended consequences and may hurt performance. If you encounter performance problems with a LINQ query, a cast like the one shown here is one possible place to begin looking for the culprit. (The one exception to this rule is when you are working with a nongeneric Enumerable, in which case you should use the cast.)

Вам не нужно записывать имя типа, и это не менее эффективно, чем тип разрешается во время компиляции.

Удалено из соображений избыточности.

vars по-прежнему инициализируются как правильный тип переменной - компилятор просто определяет его из контекста. Как вы упомянули, var позволяет нам хранить ссылки на экземпляры анонимных классов, но также упрощает изменение вашего кода. Например:

// If you change ItemLibrary to use int, you need to update this call
byte totalItemCount = ItemLibrary.GetItemCount();

// If GetItemCount changes, I don't have to update this statement.
var totalItemCount = ItemLibrary.GetItemCount();

Да, если трудно определить тип переменной по ее имени и использованию, во что бы то ни стало явно объявите ее тип.

var неплохо. Запомни это. var неплохо. Повтори это. var неплохо. Запомни это. var неплохо. Повтори это.

Если компилятор достаточно умен, чтобы определить тип из контекста, то и вы тоже. Вам не обязательно записывать это прямо при декларировании. А intellisense делает это еще менее необходимым.

var неплохо. Запомни это. var неплохо. Повтори это. var неплохо. Запомни это. var неплохо. Повтори это.

Если вы знаете тип, используйте его. Если вы не знаете тип, почему бы и нет? Если вы не можете узнать тип, ничего страшного - вы нашли единственно верное применение.

Мне очень жаль, но если лучшее, что вы можете сделать, это «привести весь код в соответствие», это плохой ответ. Найдите другой способ форматирования вашего кода.

«Единственное, что вы действительно можете сказать о моем вкусе, это то, что он старомоден, и со временем ваш будет тоже». -Толкин.

var хорош, поскольку следует классическому правилу DRY , и особенно элегантен, когда вы указываете тип в той же строке, что и объявление переменной. (например, var city = new City () )

Это не неправильно, но может быть неуместно. Смотрите все другие ответы для примеров.

var x = 5; (плохо)

var x = новый SuperDooperClass(); (хорошо)

var x = от t в db. Что-то выбрать новый { Property1 = t.Field12 }; (лучше)

Не используйте это, это сделает ваш код нечитаемым.

ВСЕГДА используйте как можно более строгий набор текста, костыли только превращают вашу жизнь в ад.

Ответ Эрика здесь ...

Псевдонимы с областью имен для универсальных типов в C #

связаны.

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

Первое.

var - это не тип и не какая-то специальная функция (например, C # 4.0 dynamic ). Это просто синтаксический сахар. Вы просите компилятор определить тип по выражению в правой части. Единственное необходимое место - анонимные типы.

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

Один хороший аргумент, почему vars не должен использоваться как простой «ярлык для ввода», а вместо этого должен использоваться для сценариев, для которых они были в первую очередь разработаны: Resharper (по крайней мере, v4.5) не может найти использование типа, если он представлен как var. Это может стать реальной проблемой при рефакторинге или анализе исходного кода.

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

var iCounter = 0;

жив!

Мальчик, я скучаю по VB.

то, что большинство игнорирует:

var something = new StringBuilder(); 

обычно не набирается так быстро, как

StringBuilder something = KEY'TAB'();