Использование неявно типизированных локальных переменных

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

public string SomeMethod(int aParam)
{
    int aNumber = SomeOtherMethod(aParam);
    // should be changed to:
    var aNumber = SomeOtherMethod(aParam);
}

Я думаю, что явно типизированные переменные более читабельны (более явные).

Что вы думаете о предложении ReSharper? Есть ли преимущество в использовании неявно типизированных переменных? Когда вы используете неявные/эксплицитные вары?

Ответ 1

Я лично использую только "var" , когда я могу четко различать переменную Type, просто прочитав объявление, например:

var someVariable = new List<int>();

В приведенном выше примере очевидно, что "var" относится к "List <int> ".

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

var someVaraible = SomeMethod();

Я имею в виду, что должна возвращаться функция "SomeMethod"? Можете ли вы рассказать, просто взглянув на строку кода? Нет, вы не можете, поэтому я избегаю использования "var" в этих ситуациях.

Ответ 2

Там много дискуссий об этом, но я думаю, что все сводится к личным вкусам, точно так же, как и с использованием ключевого слова 'this' почти везде.

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

Dictionary<string, Dictionary<string, string>> myDictionary = new Dictionary<string, Dictionary<string, string>>();

против

var myDictionary = new Dictionary<string, Dictionary<string, string>>();

EDIT: эта тема SO охватывает ту же тему, с некоторыми хорошими ответами: Что использовать: var или тип имени объекта?

EDIT2: В настоящее время много работает с асинхронизмом, я нахожу, что использование переменных типизированного типа может иногда предотвращать неприятные ошибки. Рассмотрим этот глупый пример, в котором вы хотели бы вернуть идентификатор пользователя. Также считайте, что GetUserAsync возвращает a Task<User>. Если вы используете неявно типизированные переменные, вы можете использовать что-то вроде этого:

public long GetUserId()
{
  var user = GetUserAsync();
  return user.Id;
}

Это компилируется, но это неправильно. "Пользователь" на самом деле является Task<User>. И он компилируется, поскольку Task также имеет свойство Id. В этом случае можно случайно вернуть идентификатор задачи вместо пользователя.

public long GetUserId()
{
  User user = GetUserAsync();
  return user.Id;
}

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

На самом деле это случилось со мной однажды: -)

Ответ 3

На всякий случай какой-то havent заметил, вы можете легко изменить "предложения" в Reshaper (Reshaper → Options → Languages - > Context Actions → "Заменить спецификацию явного типа на" var ").

Я лично предпочитаю иметь явные спецификации типа везде, но я не слишком суетлив.

Ответ 4

Просто проще вводить псевдо-ключевое слово var в разное время, чем огромное имя типа, особенно если это может быть связано с общим. Однако вы должны знать, что они функционально идентичны. Там нет разницы в производительности или что-либо в любом случае. Компилятор выводит тип правой части задания и заменяет var этим типом. Это не происходит во время выполнения, как вариант VB.

Ответ 5

FWIW, ключевое слово var легко читается во многих случаях. Особенно, если...

Правая часть присваивания является выражением конструктора.

var map = новый словарь > ();
Локальные переменные имеют хорошие имена.

НТН