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

Когда я говорю

public static IMyType GetGateWayManager()
{
    IUnityContainer _container = GetContainer();
    IMyType _gateWayManager = _container.Resolve<IMyType>();
    return _gateWayManager;
}

он содержит предупреждение Use implicitly types local variable.

Если я изменю его на

public static IMyType GetGateWayManager()
{
    IUnityContainer _container = GetContainer();
    var_gateWayManager = _container.Resolve<IMyType>();
    return _gateWayManager;
}

это нормально.

Может ли кто-нибудь сказать мне, почему редактор VS считает, что лучше использовать var здесь?

Ответ 1

Кто такие типы?

Компилятор? Да, конечно. Компилятор использует типы, чтобы сделать его более вероятным, чтобы ваша программа правильно работала во время выполнения, гарантируя соответствие типов, вы вызываете фактически существующие методы и передаете им параметры нужного типа. Здесь компилятор проверяет, что вы действительно возвращаете что-то типа IMyType.

Редактор? Опять же, да. Редактор использует информацию о фоновой компиляции и типе, чтобы помочь вам написать код. Когда вы нажмете . после _container, он использует информацию о типе, чтобы сообщить вам, что существует метод Resolve и какие параметры он принимает.

Вы? Не так много. Мы уже видели, что компилятор гарантирует, что вы вернете что-то типа IMyType, так почему вы заботитесь о том, чтобы объявить его как этот тип, когда компилятор может его обработать и проверить его для вас? Точно так же редактор расскажет вам о методах в контейнере, поэтому почему вы заботитесь о том, является ли это контейнером Unity или каким-либо другим типом контейнера, если вы уже знаете из имени переменной, что это контейнер какого-либо типа и из редактор, который имеет метод Resolve.

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

public static IMyType GetGateWayManager()
{
    var container = GetContainer();
    var gateWayManager = container.Resolve<IMyType>();
    return gateWayManager;
}

Ответ 2

с использованием var вместо явного типа предлагается resharper, потому что это понятно и полезно.

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

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

Пример:

int id = getId();
List<MyType> myList = FindById(id);

В этой ситуации, если вы меняете id из int на guid, вы должны изменить этот "int" здесь. Это мало, но легко может стать большим в реальных проектах. С var у вас есть какой-то код для компилятора и не нужно постоянно его менять.

var id = getId();
var myList = FindById(id);

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

Помните: var изменен во время компиляции для исправления типа. Он отличается от динамики, которая не решается почти во всех случаях.

Ответ 3

Может быть, это ReSharper.

ReSharper рекомендует использовать var, когда тип переменной можно увидеть в коде. В вашем примере мы видим, что _gateWayManager будет иметь тип IMyType, тогда мы используем ключевое слово var для неявной типизации переменной. _container будет явно введен в код, потому что мы не можем сказать, какой объект будет возвращен GetContainer()

Ответ 4

Вероятно, это не редактор VS, а ReSharper, который дает вам это сообщение. Это скорее вопрос вкуса, чем лучшая практика. Но как только вы привыкнете к ключевому слову var, вы начинаете все больше и больше. По крайней мере, я научился любить его.

Ответ 5

Это Resharper предупреждает вас, а не редактор VS.