Коллекция ‹T› против списка ‹T›, что вы должны использовать в своих интерфейсах?

Чтобы ответить на «почему» часть вопроса, почему не _ 1_, Причины - ориентированность на будущее и простота API.

Ориентация на будущее

List<T> не предназначен для простого расширяемый, создавая подклассы; он разработан, чтобы быть быстрым для внутреннего внедрения. Вы заметите, что методы на нем не виртуальные и поэтому не могут быть переопределены, и в его _ 3_ / _ 4_ / _ 5_ операций.

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

Таким образом, возвращая любой класс, который можно легко разделить на подклассы, например Collection<T> или такой интерфейс, как IList<T>, _8 _ или IEnumerable<T>, вы можете изменить свой внутренняя реализация должна быть другим типом коллекции для удовлетворения ваших потребностей, не нарушая кода потребителей, потому что он все еще может быть возвращен как тип, который они ожидают.

Простота API

List<T> содержит множество полезных операций. например BinarySearch, _ 12_ и так далее. Однако, если вы раскрываете эту коллекцию, вполне вероятно, что вы контролируете семантику списка, а не потребителей. Таким образом, хотя вашему классу внутри могут потребоваться эти операции, очень маловероятно, что потребители вашего класса захотят (или даже должны) их вызвать.

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

Я бы лично заявил, что он возвращает интерфейс, а не конкретную коллекцию. Если вам действительно нужен доступ по списку, используйте IList<T>. В противном случае рассмотрите ICollection<T> и _ 3_.

Я не думаю, что кто-то еще ответил на вопрос «почему» ... так что начнем. Причина, «почему» вам «следует» использовать Collection<T> вместо List<T>, заключается в том, что если вы выставите List<T>, то любой, кто получит доступ к вашему объекту, сможет изменить элементы в списке. В то время как Collection<T> должен указывать на то, что вы создаете свои собственные методы «Добавить», «Удалить» и т. Д.

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

Если у вас есть публичный массив, например:

public int[] MyIntegers { get; }

Вы могли бы подумать, что из-за того, что существует только метод доступа «get», никто не может вмешиваться в значения, но это неправда. Любой желающий может изменить значения внутри так:

someObject.MyIngegers[3] = 12345;

Лично я бы просто использовал List<T> в большинстве случаев. Но если вы разрабатываете библиотеку классов, которую собираетесь раздать случайным разработчикам, и вам нужно полагаться на состояние объектов ... тогда вы захотите создать свою собственную коллекцию и заблокировать ее оттуда: )

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

Не рекомендуется позволять другим объектам (или людям) напрямую изменять состояние ваших объектов. Подумайте о геттерах / установщиках свойств.

Коллекция -> Для обычной коллекции
ReadOnlyCollection -> Для коллекций, которые не следует изменять
KeyedCollection -> Если вместо этого вам нужны словари.

Как это исправить, зависит от того, что вы хотите, чтобы ваш класс делал, и цели метода GetList (). Вы можете уточнить?

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

Кое-что добавить, хотя об этом давно не спрашивали.

Когда ваш тип списка является производным от List<T> вместо Collection<T>, вы не можете реализовать защищенные виртуальные методы, которые реализует Collection<T>. Это означает, что производный тип не может отвечать, если в список внесены какие-либо изменения. Это потому, что List<T> предполагает, что вы знаете, когда добавляете или удаляете элементы. Возможность отвечать на уведомления - это накладные расходы, и поэтому List<T> не предлагает их.

В случаях, когда внешний код имеет доступ к вашей коллекции, вы не можете контролировать, когда элемент добавляется или удаляется. Поэтому Collection<T> позволяет узнать, когда ваш список был изменен.

Я не вижу проблем с возвратом чего-то вроде

this.InternalData.Filter(crteria).ToList();

Если я вернул отключенную копию внутренних данных или отдельный результат запроса данных - я могу безопасно вернуть List<TItem>, не раскрывая никаких деталей реализации, и разрешить использовать возвращенные данные удобным способом.

Но это зависит от того, какой тип потребителя я ожидаю - если это что-то вроде сетки данных, я предпочитаю возвращать IEnumerable<TItem> , который в любом случае будет скопированным списком элементов в большинстве случаев :)

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

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

//using System.Collections.ObjectModel;

Collection<MyClass> myCollection = new Collection<MyClass>(myList);