Должен ли я *always* отдавать предпочтение имплицитно типизированным локальным переменным в C# 3.0?

Это, конечно, вопрос стиля, но я согласен с Dare: C# 3.0 неявные объявления типа: к var или не к var? . Я думаю, что использование var вместо явного типа делает ваш код менее читаемым. В следующем коде:

var result = GetUserID();

Что такое результат? Int, строка, a GUID? Да, это имеет значение, и нет, мне не нужно копаться в коде, чтобы узнать это. Это особенно раздражает в примерах кода.

Джефф написал сообщение об этом, сказав, что он предпочитает ВАР . Но этот парень сумасшедший!

Я вижу закономерность успеха stackoverflow: откопайте старые сообщения CodingHorror и (стиль Jeopardy) сформулируйте их в терминах вопроса.

Я использую его только тогда, когда ясно видно, что такое var.

понятный мне:

XmlNodeList itemList = rssNode.SelectNodes("item");
var rssItems = new RssItem[itemList.Count];

мне это не совсем понятно:

var itemList = rssNode.SelectNodes("item");
var rssItems = new RssItem[itemList.Count];

Лучшее резюме ответа, которое я видел, - это комментарий Эрика Липперта, который по существу говорит, что вы должны использовать конкретный тип, если важно, что это за тип, но не иначе. По существу, информация о типе должна быть зарезервирована для тех мест, где тип является важным.

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

Большинство рекомендаций, на которые ссылаются люди (например, Dare), являются рекомендациями, сделанными людьми, которые никогда не пробовали кодировать с помощью var вместо конкретного типа. Это делает рекомендации почти бесполезными, потому что они не говорят из опыта, они просто экстраполируют.

Лучший совет, который я могу вам дать, - это попробовать его для себя и посмотреть, что работает для вас и вашей команды.

@jongalloway-var не обязательно делает ваш код более нечитабельным.

var myvariable = DateTime.Now
DateTime myvariable = DateTime.Now;

Первая так же удобочитаема, как и вторая, и требует меньше работы

var myvariable = ResultFromMethod();

здесь у вас есть точка зрения, что var может сделать код менее читаемым. Мне нравится var, потому что если я меняю десятичную дробь на двойную, мне не нужно менять ее в куче мест (и не говорите рефактор, иногда я забываю, просто дайте мне var!)

EDIT: просто прочитайте статью, я согласен. лол.

У меня есть ощущение, что это будет один из самых популярных вопросов, задаваемых в течение долгого времени по переполнению стека. Все сводится к преферансу. Все, что вы думаете, более читаемо. Я предпочитаю var, когда тип определяется с правой стороны, потому что он более лаконичен. Когда я назначаю переменную из вызова метода, я использую явное объявление типа.

Была хорошая дискуссия по этому поводу @ Coding Horror

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

Одно из преимуществ такого инструмента, как ReSharper, заключается в том, что вы можете написать код так, как вам нравится, и затем переформатировать его в нечто более доступное для обслуживания. У меня есть R#, настроенный на всегда переформатирование таким образом, что фактический используемый тип виден, однако при написании кода я почти всегда набираю 'var'.

Хорошие инструменты позволяют вам иметь лучшее из обоих миров.

Джон.

Это имеет смысл только тогда, когда вы не знаете тип заранее.

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

К объявлениям неявно типизированных переменных применяются следующие ограничения:

• var можно использовать только при объявлении и инициализации локальной переменной в том же самом операторе; переменная не может быть инициализирован null, или группа методов или анонимная функция.
• var нельзя использовать для полей в области действия класса.
• Переменные, объявленные с помощью var, не могут быть использованы при инициализации выражение. Другими словами, это выражение законно: int i = (i = 20); но это выражение вызывает ошибка компиляции: var i = (i = 20);
• Несколько неявно типизированных переменных не могут быть инициализированы в одном и том же заявление.
• Если тип с именем var находится в области видимости, то ключевое слово var разрешится в это имя типа и не будет рассматриваться как часть неявно типизированного локального объявление переменной.

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

Я вижу закономерность для stackoverflow успех: откопайте старые сообщения CodingHorror и (типа угроза) сформулировать их в условия вопроса.

Я признаю себя невиновным! Но вы правы, это был относительно популярный маленький вопрос.

"Best style" является субъективным и варьируется в зависимости от контекста.

Иногда гораздо проще использовать 'var' вместо того, чтобы вводить какое-то очень длинное имя класса, или если вы не уверены в типе возвращаемого значения данной функции. Я нахожу, что использую 'var' больше, когда путаюсь с Linq, или в объявлениях цикла for.

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

Я чувствую, что это зависит от разработчика, чтобы принять решение. Нет никакой серебряной пули. Нет "one true way".

Ваше здоровье!

Нет, не всегда , но я бы сказал, что очень часто. Объявления типов не намного более полезны, чем венгерская нотация когда-либо была. У вас все еще есть та же проблема, что типы могут изменяться, и как бы ни были полезны инструменты рефакторинга для этого, это не идеально по сравнению с тем, чтобы не менять, где тип указан, кроме как в одном месте, которое следует принципу "не повторяйся".

Любой однострочный оператор, в котором имя типа может быть указано как для переменной, так и для ее значения, должен определенно использовать var, особенно если это длинный Generic< OtherGeneric< T, U, V>, Dictionary< X, Y>>>