Кто-либо нашел использование “var” кроме для LINQ?

Я очень часто использую его в циклах foreach :

foreach(var item in collection)

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

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

// the compiler may be able to infer the type
// of "foo" but I certainly cannot without 
// viewing the implementation of "doSomething".
var foo = doSomething();

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

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

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

И если я не могу, я использую Intellisense VS 2008, чтобы помочь мне, или я просто используйте Resharper var => преобразователь имени класса, чтобы преобразовать его в явное имя.

Другой случай, который я считаю большим использованием var , - это цикл foreach :

foreach(var id in idList)
{
  // do what you will here
}

Как насчет анонимных классов?

var mySomething = new { Name = "Hello", Age=12 };

Да, я использую его все время при создании объектов для класса с длинным именем и в foreach loop

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

Еще одно важное ограничение var - вы не можете использовать его как параметр метода или как возвращаемый тип . Вы даже не можете объявить его полем в классе. Это означает, что мы можем использовать var только для экономии времени на набор текста или для того, чтобы сделать код менее подробным для «удобочитаемости» и с LINQ

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

Как уже упоминали другие, его также приятно использовать при инициализации новых экземпляров объектов ; имеющий Foo foo = new Foo (); является избыточным. var foo = new Foo (); так же читабельно, даже лучше, если есть несколько объявлений ...

var connString = BuildConnectionString();
var sqlConn = new SqlConnection(connString);
var commandText = BuildCommandText();
var sqlComm = new SqlCommand(commandText, sqlConn);

vs.

string connString = BuildConnectionString();
SqlConnection sqlConn = new SqlConnection(connString);
string commandText = BuildCommandText();
SqlCommand sqlComm = new SqlCommand(commandText, sqlConn);

При использовании MVC и наличии клиентского контроллера для возврата всех ваших запросов ajax вы почти всегда будете использовать var, потому что с анонимным типом вы можете отправить обратно только те данные, которые необходимы приложению. клиенту.

var response = new { var1 = "bla", var2 = "foo" };
return JSon(response);

Я где-то читал, что рекомендуется использовать "var" в случаях, когда вы вызываете код в модуле, написанном не вами, и который возвращает объект, тип которого зависит от будущие изменения. Если бы вы написали оболочку для этого внешнего модуля и пересылали бы только результат, то использование var для временного хранения сделало бы ваш код действительным, если / когда тип данных, возвращаемый внешним вызовом, изменится. Кроме того, если вы знаете, что этот результат представляет собой некую коллекцию, но, опять же, не особо стабильного типа, присвоение переменной var и последующее повторение могут все еще работать в случае дальнейшего изменения.

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

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

List<T> GetList()
{
    return myList;
}

У меня могут быть повсюду строки кода, выполняющие присваивание локальной переменной, которое выглядит следующим образом:

List<T> list = GetList(); 

Если я изменю GetList (), чтобы вместо этого возвращать IList , тогда мне придется изменить все эти строки присваивания . N строк назначения равны N + 1 изменения кода, если я изменю тип возвращаемого значения.

IList<T> GetList()
{
    return myList;
}

Если бы вместо этого я закодировал следующим образом:

var list = GetList(); 

Тогда мне нужно только изменить GetList (), а остальное будет проверено через компиляция. Мы начали работать с одним изменением кода. Конечно, компилятор будет жаловаться, если код, зависящий от списка, был List , а не IList ; но их должно быть меньше N.

IList<T> GetList()
{
    return myList;
}

Если бы вместо этого я закодировал следующее:

var list = GetList(); 

Тогда мне нужно только изменить GetList (), а все остальное будет проверено путем компиляции. Мы начали работать с одним изменением кода. Конечно, компилятор будет жаловаться, если код, зависящий от списка, был List , а не IList ; но их должно быть меньше N.

IList<T> GetList()
{
    return myList;
}

Если бы вместо этого я закодировал следующее:

var list = GetList(); 

Тогда мне нужно только изменить GetList (), а все остальное будет проверено путем компиляции. Мы начали работать с одним изменением кода. Конечно, компилятор будет жаловаться, если код, зависящий от списка, был List , а не IList ; но их должно быть меньше N.