Каковы некоторые преимущества и недостатки вывода типа в C #?

Question

У меня есть коллега, который против вывода типов в C #.Я полагаю, что большинство его аргументов окружало отсутствие читабельности.Мой аргумент против этого заключается в том, что функции IntelliSense в Visual Studio предоставляют простой способ просмотра типов, и чтение их из кода не так необходимо, как это могло бы быть, если бы мы кодировали из блокнота.

Однако яМне любопытно о преимуществах и недостатках использования вывода типа в C #.Я из C ++, и я знаю, что «auto» в C ++ 0x имеет более объективное преимущество в том, что вы не всегда знаете, какие типы вы получаете (особенно при выполнении сложных шаблонных программ).Примером является использование auto для хранения значения Boost.Bind.

В C # вывод типа не является таким уж большим требованием, как «приятно иметь» или сахар.особенность покрытия.Я думаю, что это было бы полезно, когда вы имеете дело с длинными типами, например:

Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>> myVar = obj.GetLazy();

, это будет:

var myVar = obj.GetLazy();

На мой взгляд, это намного чище.Однако есть ли объективные аргументы для ИЛИ против вывода типа?Является ли это хорошей практикой программирования, чтобы использовать его, даже в ситуациях, когда можно утверждать, что это не дает никакой выгоды (например, использование «var» вместо «int»)?

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

Answer 1

Вывод типа был придуман именно по той причине, которую вы даете для C ++, вы можете создавать анонимные типы, не имеющие имени типа (см., В частности, Lambdas и Linq).

Так что в этом случае это необходимо.

В другом случае (когда имя типа известно) оно сводится к стилю. Я использую var, когда тип действительно очевиден:

// I like this - less duplication and easier to read
var item = new List<ComplexObjectItem>();

вместо:

List<ComplexObjectItem> item = new List<ComplexObjectItem>();

Потому что это уменьшает дублирование.

Однако я предпочитаю не использовать его, когда тип не сразу очевиден для читателя:

// I don't like this - I need to look up what the type is
var item = ResultOfSomeFunctionWhereICantSeeWhatItIs();

Но ваш пробег может отличаться.

Answer 2

Я думаю, что здравый смысл диктует следующие неформальные правила:

Если есть какое-то длинное имя, например:

Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>> myVar = new Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>>();

затем заменить его на

var myVar = new Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>>();

имеет смысл, потому что вы все еще можете сказать, что это за объект.

Что-то двусмысленное, с другой стороны, может не оправдать использование var:

Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>> myVar = doProcess();

Answer 3

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

Одна вещь, которую нужно запомнить, var только для пользователя, компилятор преобразует еек его конкретному представлению при компиляции.

Единственным недостатком является использование интерфейсов из класса.

при условии, что GetCurrentList() возвращает IList<string>:

IEnumerable<string> list = GetCurrentList();

и

var list = GetCurrentList();

не такие, как во втором примере, список будет IList<string>.

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

Answer 4

Вывод типа необходим при работе с анонимными типами:

var x = new { Greeting = "Hello", Name = "World" };

Когда вы используете запросы LINQ, вы обычно всегда используете анонимные типы.

Answer 5

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

var myClass = new MyClass();

НО

MyClass myClass = RandomFuncThatGetsObject();

Я думаю, что использование var в первом примере не влияет на читабельность, на самом деле это делает его более читабельным, однако использование var во втором примере БУДЕТ влиять на читаемость.

Answer 6

var myVar = obj.GetLazy();

Такой вывод типа, при наличии intellisense, является примерно хорошей идеей, или все в порядке.Однако, если бы не было intellisense, то я бы не посчитал это хорошей идеей.Это был бы кошмар вместо этого.Я полагаю, что без intellisense большинству разработчиков это не понравится из-за неудобства, вызванного отсутствием intellisense (и точного типа, оба).

Однако, даже без intellisense, было бы хорошо следующее:

var obj = new Lazy<List<MyNamespace.ISomeVeryLongInterfaceType>();

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

С IntelliSense или без, я предпочитаю писать:

Lazy<List<MyNamespace.ISomeVeryLongInterfaceType> obj= obj.GetLazy();