Почему var был бы плохой вещью?

У меня были случаи (когда я foreach через Таблицу. Набор строк), когда использование var привело к типу, являющемуся некоторого базового класса, а не фактического типа DataRow. Это - единственное время, я испытал затруднения из-за var.

От Отдел Отдела Дублирования Объявления (от Jeff Ужас Кодирования ):

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

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

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

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

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

Это - действительно проблема удобочитаемости с Вашим кодом.

Мое персональное предпочтение состоит в том, чтобы только когда-либо использовать "var" для анонимных типов (действительно, если Вы хотите использовать анонимные типы вообще, то необходимо будет использовать var), и они главным образом прибывают из запросов LINQ. В этих случаях у Вас нет выбора, кроме как использовать var, если Ваш запрос проектирует в новое (неявный & анонимный) тип.

Однако C# 3.0 счастливо позволит Вам использовать var где угодно, Вам нравится, за пределами LINQ и анонимных типов, например:

var myint = 0;
var mystring = "";

совершенно допустимо, и myint, и mystring будет со строгим контролем типов выведенными значениями, используемыми для инициализации их. (таким образом myint является Система. Int32 и mystring является Система. Строка). Конечно, это довольно очевидно при рассмотрении значений, используемых для инициализации переменных, что вводит, они будут неявно введены к, однако, я думаю, что для удобочитаемости кода еще лучше, если вышеупомянутое было записано как:

int myint = 0;
string mystring = "";

, так как Вы видите сразу сразу точно, которые вводят те переменные.

Рассматривают этот несколько запутывающий сценарий:

var aaa = 0;
double bbb = 0;

Совершенно действительный код (если немного нетрадиционный), но в вышеупомянутом, я знаю, что bbb является двойным, несмотря на значение инициализации, кажущееся быть интервалом, но aaa определенно не будет двойным, а скорее интервал

Запрещение его полностью означает запрещать использование анонимных типов (которые становятся невероятно полезными, поскольку Вы используете LINQ больше).

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

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

Ваш друг просто неудачен, что они работают ниже одного из экстремистов.

Во-первых, как правило, кодирование стандартов должно быть обсуждено и согласовано командой, и обоснование позади них должно быть записано, так, чтобы любой мог знать, почему они там. Они не должны быть Святой Истиной от Одного Ведущего устройства.

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

1. , Он не уменьшает безопасность типов
2. , Он на самом деле увеличит безопасность типов в Вашем коде путем предупреждения Вас неявным броскам. Лучший пример в foreach операторе
3. Поддерживает принципы DRY в C#. Это специально для случая объявления, почему беспокойство, говоря имя дважды?
4. В некоторых случаях это, утончаются требуемые. Пример анонимные типы
5. Меньше ввода без потери функциональности.

http://blogs.msdn.com/jaredpar/archive/2008/09/09/when-to-use-type-inference.aspx

Конечно, это - ошибка. Это - потому что некоторые люди не понимают, что это на самом деле со строгим контролем типов, и нисколько как var в VB.

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

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

существуют несколько раз, когда неясно, что Вы повредили вещи путем изменения его - главным образом, когда инициализированный тип и (исходный) тип переменной не являются тем же, потому что:

• переменная была первоначально базовым классом
• , переменная была первоначально интерфейсом
• , переменная была первоначально другим типом с неявным оператором преобразования

В этих случаях, можно попасть в беду с любым разрешением типа - например:

• методы, которые имеют различные перегрузки для двух конкурирующих типов
• дополнительные методы, которые определяются по-другому для двух конкурирующих типов
• участники, которые были повторно объявлены (скрытые) на одном из типов
• , универсальный вывод типа будет работать по-другому
• , разрешение оператора будет работать по-другому

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

Примеры:

Неявное преобразование:

static void Main() {
    long x = 17;
    Foo(x);
    var y = 17;
    Foo(y); // boom
}
static void Foo(long value)
{ Console.WriteLine(value); }
static void Foo(int value) {
throw new NotImplementedException(); }

сокрытие Метода:

static void Main() {
    Foo x = new Bar();
    x.Go();
    var y = new Bar();
    y.Go(); // boom
}
class Foo {
    public void Go() { Console.WriteLine("Hi"); }
}
class Bar : Foo {
    public new void Go() { throw new NotImplementedException(); }
}

и т.д.

var q = GetQValue();

действительно плохая вещь. Однако

var persistenceManager = ServiceLocator.Resolve<IPersistenceManager>();

прекрасно подходит мне.

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

Как заметка на полях: Интересно, как они имеют дело с анонимными типами при отсутствии разрешения использовать var ключевое слово. Или они не используют их в целом?

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