Избыточность в C#?

Всегда можно было сказать:

 var distances = new List<int>();

Потому что мы зависимы от компиляторов и ошибок компилятора.

C# определенно становится менее многословным после добавления функциональной поддержки.

Исторический артефакт статической типизации / синтаксиса C; сравните пример Ruby:

distances = []

Что в этом лишнего?

List<int> listOfInts = new List<int>():

Переведено на английский: (РЕДАКТИРОВАТЬ, немного подчистил для пояснения)

• Создайте указатель типа List <int> и назовите его listofInts.
• listOfInts теперь создан, но это просто указатель ссылки, указывающий в никуда (ноль)
• Теперь создайте объект типа List <int> в куче и верните указатель на listOfInts.
• Теперь listOfInts указывает на List <int> в куче.

Не очень многословный, если подумать о том, что он делает.

Конечно, есть альтернатива:

var listOfInts = new List<int>();

Здесь мы используем вывод типа C#, потому что вы назначаете его немедленно, C# может определить, какой тип вы хотите создать, с помощью объекта, только что созданного в куче.

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

Улучшения компилятора для C# 3.0 (который соответствует .Net 3.5) устраняют некоторые подобные вещи. Итак, ваш код теперь можно записать как:

var distances = new List<int>();

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

При этом есть еще некоторые области, которые можно улучшить. Некоторые из них связаны с API, а некоторые просто из-за ограничений строгой типизации.

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

Я бы предпочел это (C#)

int i;

к этому (VB.NET)

Dim i as Integer

Выбранный вами конкретный пример касается .NET в целом, что немного длиннее, но я не думаю, что это вина C#. Может быть, вопрос стоит перефразировать: "Почему код .NET такой многословный?"

Потому что объявление типа не обязательно имеет ничего общего с его инициализацией.

Я могу заявить

List<int> foo; 

и оставьте его для инициализации позже. Где же тогда избыточность? Возможно, он получает значение от другой функции, например BuildList ().

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

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

1. Переменная с именем Distance типа List<int>.
2. Объект в куче типа List<int>.

Учтите следующее:

Person[] coworkers = new Employee[20];

Здесь отсутствие избыточности более очевидно, поскольку переменная и выделенный объект относятся к двум разным типам (ситуация допустима, если тип объекта является производным от типа переменной или реализует его).

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

вместо того, чтобы иметь

Перечислить расстояния; расстояния = новый список ();

C# позволяет поместить их в одну строку.

В одной строке написано: «Я буду использовать переменную с именем расстояния, и она будет типа List». В другой строке говорится: «Выделите новый список и вызовите конструктор без параметров».

Это слишком избыточно? Возможно. это даст вам кое-что, хотя

1. Отделяет объявление переменной от размещения объекта. Разрешение:

IEnumerable<int> distances = new List<int>();
// or more likely...
IEnumerable<int> distances = GetList();

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

Оба ли они необходимы для написания программного обеспечения? Нет. Есть много языков, которые этого не делают и / или различаются по многим другим пунктам.

"Доктор! Мне больно, когда я это делаю!" - "Не делай этого больше"

Если вы обнаружите, что вам не нужны или не нужны вещи, которые дает вам C#, попробуйте другие языки. Даже если вы не используете их, знание других может дать вам огромный толчок в подходе к решению проблем. Если вы его используете - отлично!

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

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

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

Однако основная причина, по которой они ввели вар, была для анонимных типов, у которых нет имени:

var x = new {Foo = Bar, Number = 1};

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

К счастью, Эрик Липперт пишет об этом более красноречиво, чем я: http://csharpindepth.com/ViewNote.aspx?NoteID=63http://csharpindepth.com/ViewNote.aspx?NoteID=61

Используйте var, если читателю очевидно, что это за тип.

//Use var here
var names = new List<string>();

//but not here
List<string> names = GetNames();

От микрософтс Руководство по программированию на C#

The var keyword can also be useful when the specific type of the variable is tedious to type on the keyboard, or is obvious, or does not add to the readability of the code

Также может:

var distances = new List<int>();

Я вижу еще одну проблему с использованием var для такой лени

var names = new List<string>();

Если вы используете var, переменная с именем "names" набирается как List<string>,, но в конечном итоге вы будете использовать только один из интерфейсов, унаследованных от List<T>..

IList<string> = new List<string>();
ICollection<string> = new List<string>();
IEnumerable<string> = new List<string>();

Вы можете использовать все это автоматически, но можете ли вы подумать, какой интерфейс вы хотели использовать во время написания кода?

Ключевое слово var не улучшает читаемость в этом примере.

Это только «избыточно», если вы сравниваете его с динамически типизированными языками. Это полезно для полиморфизма и поиска ошибок во время компиляции. Кроме того, это упрощает автоматическое заполнение кода / intellisense для вашей среды IDE (если вы ее используете).

Во многих ответах на этот вопрос авторы мыслят как составители или апологеты. Важное правило хорошего программирования - Не повторяйся!.

Избежать этого ненужного повторения можно с помощью явная цель дизайна Go, например:

Stuttering (foo.Foo* myFoo = new(foo.Foo)) is reduced by simple type derivation using the := declare-and-initialize construct.