Есть ли техническая причина использовать или не использовать var в C #, когда тип известен?

Question

Кажется, что все больше и больше кода C #, который я читаю, использует идентификатор типа var :

foreach (var itemChange in ItemChanges)
{
   //... 
}

вместо явно с указанием типа:

foreach (ItemChange itemChange in ItemChanges)
{
   //... 
}

даже когда тип известен.

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

Но есть ли техническая причина для использования одного или другого?

Answer 1

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

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

var obj = SomeMethod(); // what's the type? you'd have to inspect SomeMethod()
SomeClass obj = SomeMethod(); // the type is obvious

но другие случаи, когда использование var имеет смысл, например

var obj = new SomeClass(); // the type is obvious
SomeClass obj = new SomeClass(); // the duplication of type is unnecessary

Answer 2

Нет, просто читабельность.

Answer 3

var - это функция C # 3.0, обязательная только для анонимного типа

Потому что следующий код

var v = new { Amount = 108, Message = "Hello" };

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

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

Answer 4

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

int i = 5;
double a = i; // implicit cast with explicit types

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

var a = (double)i; // explicit cast with implicit types

Но на самом деле главная причина - это читаемость, как вы сказали. Вопрос, который вам нужно задать себе, - почему вы считаете, что конкретный тип важен для удобства чтения? Вы всегда пишете запросы Linq, вызывая конкретный тип, например,

from ItemChange itemChange in ItemChanges

// instead of

from itemChange in ItemChanges

Аналогично, вы всегда вызываете аргументы типа для универсальных методов вместо использования вывода типа, например,

ItemChanges.Select<ItemChange, ItemChange>((ItemChange itemChange) => ...);

// instead of

ItemChanges.Select(itemChange => ...);

Или вы рады, что компилятор поработал за вас и позволил ему работать с типами, за счет «отсутствия» явно указанной информации о типе?

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

Answer 5

В общем нет технической причины. Читаемость - в любом направлении - единственный реальный фактор.

Однако одно маленькое предостережение заключается в том, что var выведет тип переменной static . Если вам нужен тип подкласса или суперкласса, вам нужно выполнить кастинг самостоятельно. В случае foreach, как в вашем примере, вы обычно можете выполнить даункастинг за вас "бесплатно", просто объявив переменную цикла с типом подкласса.

Классическим примером является перебор XML NodeList, который, как вы знаете, представляет собой список XmlElement, но Nodelist вводится как набор XmlNode с. Конечно, вы можете использовать приведение или as, чтобы получить желаемый тип, но это, похоже, лишает цели использования вывода типа: -)

Конечно, компилятор сообщит вам об этом, как только вы попытаетесь использовать элемент узла, который доступен только для XmlElement - так что это все же не является чисто техническим отличием.

---

Другая вещь, которая немного раздражает, заключается в том, что если вы используете такой инструмент, как Resharper, то очень агрессивно предлагаете использовать var в любой возможной ситуации. Это особенно раздражает, когда рекомендует изменить, например, объявление int на var!

Однако, если вы не отключите эту функцию, вы будете получать меньше шума от Resharper, чем больше вы используете var.

Answer 6

var - это функция C # 3.x +, не так ли? без этого ваш код более совместим с другими версиями.

И в SO возникает много интересных вопросов при поиске " var C # "

Answer 7

Нет. Используйте var там, где это улучшает читаемость и наоборот.

Answer 8

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

Однако использование var позволяет программе изменять без необходимости ее редактирования. Учитывая

public int SomeMethod(){}
public List<T> SomeOtherMethod<T>(T parameter);

тогда

var x = SomeMethod();
var y = SomeOtherMethod(x);

Будет работать (и у будет List<int>). Если бы вы использовали

int x = SomeMethod();
List<int> y = SomeOtherMethod(x);

затем, если SomeMethod() были изменены, чтобы вернуть long, тогда вам придется изменить определение y.

Я видел, как подобные вещи распространяются по всей программе и требуют сотен изменений. Частным случаем было изменение кода доступа к данным, чтобы он возвращал ReadOnlyCollection<T> вместо List<T>. Требовалось так много изменений кода, что я изменил все явные упоминания List<T> на var, и код больше никогда не потребуется менять.