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

Ответ 1

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

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

var obj = SomeMethod(); // what 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

Ответ 2

Нет, просто читаемость.

Ответ 3

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

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

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

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

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

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

Ответ 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 и generic, то вы уже приняли решение, что вы в порядке, не имея типов, явно прописанных повсюду, и вы, вероятно, не обнаружили, что ваш код в любом случае менее читаемым (на самом деле вы, вероятно, нашли совершенно противоположное). Таким образом, использование var - это еще один шаг по тому же пути, на котором вы уже находитесь.

Ответ 5

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

Поскольку следующий код

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

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

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

Ответ 6

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

Ответ 7

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

И есть много интересных вопросов в SO, когда вы выполняете поиск var С#"

Ответ 8

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

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

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

затем

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

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

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

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

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

Ответ 9

Да, они разные. var удаляет исходный тип данных и один тип проверки данных, поэтому его более опасно.

Type-чеки

Стандартное определение переменной включает проверку типа данных при первоначальном назначении.

T a = init;     // type-checked
a = b;          // type-checked
a = c;          // type-checked

Этого не хватает, если вы используете var

var a = init;   // NOT type-checked
a = b;          // type-checked
a = c;          // type-checked

Эти тесты времени компиляции - это клей, который объединяет большие программы. Удаление их глупо.

Случайные изменения

Нормальное определение переменной имеет фиксированный тип - его нельзя случайно изменить.

TOrig a = init(e);         // datatype fixed (as intended)

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

var a = init(e);           // datatype changes with init and e

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

Пример:

    public double MaxValue = 1.2;

    ... meanwhile, in another source file ...

    var x = MaxValue - 1;
    var y = IsFull(x);

Оба типа данных x и y могут быть случайно изменены путем редактирования MaxValue.
Q. Это уже произошло?

Резюме

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

Чем больше движущихся частей имеет машина, тем вероятнее, что она сломается.

Явные типы данных предотвращают ошибки.