Явное определение переменных типов данных и использование ключевого слова «var»? [закрыто]

В C # я рекомендую использовать универсальное ключевое слово var для каждого объявления переменной? Если да, нужно ли упоминать эти специальные символы для литеральных значений в объявлении переменной, такие как M для десятичного, в следующем выражении:

var myDecimal = 14.5M;

Если это имеет значение, я пытаюсь заняться веб-разработкой на C #.

Было много споров по поводу использования var. Мои общие правила следующие.

• Когда тип очевиден, например, когда правая часть присваивания является конструктором, используйте var.
• Когда тип сложен для написания, например, запрос LINQ (в первую очередь причина var), используйте var.
• Для амбивалентных типов (например, для десятичного числа), где вы хотите убедиться, что ваша переменная введена правильно, укажите это по буквам.
• Анонимные типы должны использовать var.
• Во всех остальных случаях укажите тип.

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

Когда использовать varэто программирование "священная война". Существует только одно место, где это требуется: когда результат операции создает анонимный тип, такой как:

var result = new { Name = "John", Age = 35 };

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

И да, вам понадобятся специальные символы для литералов, чтобы компилятор знал, что это справа. В вашем примере, без M, по умолчанию doubleвместо decimal.

Из MSDN :

Тем не менее, использование var действительно может сделать ваш код более сложным для понимания другими разработчиками. По этой причине документация C # обычно использует var только тогда, когда это требуется.

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

var myFloat=100f;

в

var myFloat=100;

или

var myFloat=100.0;

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

Неявная типизация также не работает везде (из той же ссылки MSDN)

var можно использовать только тогда, когда локальная переменная объявлена ​​и инициализирована в том же операторе; переменная не может быть инициализирована нулем, или группой методов, или анонимной функцией.

var нельзя использовать для полей в области видимости класса.

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

Несколько переменных с неявным типом не могут быть инициализированы в одном выражении.

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

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

Обновление 2017

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

Справочник C # показывает следующее, чтобы проиллюстрировать хорошее и плохое использование этой конструкции:

В следующем примере показаны два выражения запроса. В первом выражении использование var разрешено, но не обязательно, поскольку тип результата запроса может быть явно указан как IEnumerable. Однако во втором выражении должна использоваться переменная, потому что результатом является коллекция анонимных типов, а имя этого типа недоступно, кроме как для самого компилятора. Обратите внимание, что в Примере № 2 элемент переменной итерации foreach также должен быть неявно типизирован.

 // Example #1: var is optional because 
    // the select clause specifies a string 
    string[] words = { "apple", "strawberry", "grape", "peach", "banana" };
    var wordQuery = from word in words
                    where word[0] == 'g'
                    select word;

    // Because each element in the sequence is a string,  
    // not an anonymous type, var is optional here also. 
    foreach (string s in wordQuery)
    {
        Console.WriteLine(s);
    }

    // Example #2: var is required because 
    // the select clause specifies an anonymous type 
    var custQuery = from cust in customers
                    where cust.City == "Phoenix" 
                    select new { cust.Name, cust.Phone };

    // var must be used because each item  
    // in the sequence is an anonymous type 
    foreach (var item in custQuery)
    {
        Console.WriteLine("Name={0}, Phone={1}", item.Name, item.Phone);
    }

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

Для меня я не использую var для следующих случаев:

• Когда я хочу быть уверен в типе моей переменной (например, чтобы убедиться, что используемый тип является двойным, а не десятичным, и это большое дело, поверьте мне!)
• Полиморфный код вроде Fruit foo = new Apple();. В этом случае я думаю, что var - это избегать, и лучше использовать родительский класс (здесь Fruit), позволяя лучше понять логику кода и ограничить возможные ошибки (С var, нет проверки на полиморфную концепцию!)

В остальном, я думаю, это зависит от случая и от фона разработчика. Некоторые люди из мира PHP предпочитают не заботиться о типах переменных, а некоторые из мира Java просто подумают, что var - это ересь, и чем более многословно, тем лучше.

Вам придется составить собственное мнение :)