Когда использовать IList и когда использовать List

Рекомендации Microsoft, проверенные FxCop, не 9X_.net-framework рекомендуют использовать List в 9X_c#-language общедоступных API — отдайте предпочтение 9X_.net-framework IList.

Между прочим, теперь я почти 9X_visual-c# всегда объявляю одномерные массивы как IList, что 9X_c#.net означает, что я могу последовательно использовать 9X_c#-language свойство IList.Count, а не Array.Length. Например:

public interface IMyApi { IList GetReadOnlyValues(); } public class MyApiImplementation : IMyApi { public IList GetReadOnlyValues() { List myList = new List(); ... populate list return myList.AsReadOnly(); } } public class MyMockApiImplementationForUnitTests : IMyApi { public IList GetReadOnlyValues() { IList testValues = new int[] { 1, 2, 3 }; return testValues; } } 

IEnumerable
Вам следует попробовать использовать наименее 9X_c-sharp конкретный тип, который соответствует вашим 9X_c-sharp целям.
IEnumerable менее конкретен, чем IList.
Вы используете 9X_c-sharp IEnumerable, когда хотите перебирать элементы в коллекции.

IList
IList реализует 9X_.net-framework IEnumerable.
Вы должны использовать IList, когда вам нужен 9X_dotnet доступ по индексу к вашей коллекции, добавление 9X_.net-framework и удаление элементов и т. Д.

Список
List реализует 9X_.cs-file IList.

Есть одна важная вещь, которую люди всегда 9X_.net-framework упускают из виду:

Вы можете передать простой 9X_.net-framework массив чему-то, что принимает параметр IList, а 9X_.net затем вы можете вызвать IList.Add() и получите исключение 9X_c#-language времени выполнения:

Unhandled Exception: System.NotSupportedException: Collection was of a fixed size.

Например, рассмотрим 9X_csharp следующий код:

private void test(IList list) { list.Add(1); } 

Если вы вызовете это следующим 9X_c#.net образом, вы получите исключение времени 9X_.net-framework выполнения:

int[] array = new int[0]; test(array); 

Это происходит потому, что использование 9X_csharp простых массивов с IList нарушает принцип подстановки 9X_visual-c# Лискова.

По этой причине, если вы вызываете 9X_.cs-file IList.Add(), вы можете рассмотреть возможность использования 9X_c# List вместо IList.

Я согласен с советом Ли принимать параметры, но 9X_visual-c# не возвращать их.

Если вы укажете свои методы 9X_.cs-file для возврата интерфейса, это означает, что 9X_.cs-file вы можете изменить точную реализацию позже, и 9X_dotnet метод-потребитель даже не узнает об этом. Я 9X_c# думал, что мне никогда не придется переходить 9X_c#-language с List, но позже мне пришлось измениться, чтобы 9X_.net использовать пользовательскую библиотеку 9X_dot-net списков для дополнительных функций, которые 9X_c# она предоставляла. Поскольку я вернул только 9X_csharp IList, никому из людей, использовавших 9X_c# библиотеку, не пришлось менять свой код.

Конечно, это 9X_.cs-file нужно применять только к методам, видимым 9X_c#.net извне (т.е. публичным методам). Я лично 9X_csharp использую интерфейсы даже во внутреннем 9X_.cs-file коде, но, поскольку вы можете изменить весь 9X_visual-c# код самостоятельно, если внесете критические 9X_c#.net изменения, это не является строго необходимым.

Всегда лучше использовать самый низкий базовый 9X_c-sharp тип. Это дает разработчику вашего интерфейса 9X_dotnet или потребителю вашего метода возможность 9X_csharp использовать все, что им нравится, за кулисами.

Для 9X_.net-framework коллекций вы должны стремиться использовать 9X_.cs-file IEnumerable, где это возможно. Это дает 9X_c#-language наибольшую гибкость, но не всегда подходит.

Если вы работаете с одним методом (или даже 9X_dotnet с одним классом или сборкой в ​​некоторых 9X_c#-language случаях) и никто извне не увидит, что вы 9X_c#.net делаете, используйте полноту списка. Но 9X_dot-net если вы взаимодействуете с внешним кодом, например, когда 9X_visual-c# вы возвращаете список из метода, вам нужно 9X_csharp только объявить интерфейс, не обязательно 9X_.net-framework привязываясь к конкретной реализации, особенно 9X_dot-net если вы не можете контролировать, кто компилирует 9X_dot-net ваш код. код потом. Если вы начали с конкретного 9X_visual-c# типа и решили перейти на другой, даже если 9X_c#.net он использует тот же интерфейс, вы сломаете 9X_visual-c# чужой код, если не начали с интерфейса или 9X_c#-language абстрактного базового типа.

Чаще всего лучше использовать наиболее общий 9X_c#.net пригодный для использования тип, в данном 9X_csharp случае IList или, что еще лучше, интерфейс 9X_dot-net IEnumerable, чтобы впоследствии можно было 9X_c#.net удобно переключать реализацию.

Однако в .NET 9X_c#.net 2.0 есть одна досадная вещь — в IList нет 9X_c#.net метода Sort(). Вместо этого вы можете использовать 9X_.net-framework прилагаемый адаптер:

ArrayList.Adapter(list).Sort() 

Я не думаю, что для такого рода вещей существуют 9X_dotnet жесткие и быстрые правила, но я обычно придерживаюсь 9X_visual-c# принципа использования самого легкого из 9X_visual-c# возможных способов до тех пор, пока это 9X_c#-language не станет абсолютно необходимым.

Например, допустим, у 9X_visual-c# вас есть класс Person и класс Group. В экземпляре Group много 9X_.cs-file людей, поэтому список здесь имеет смысл. Когда 9X_.net я объявляю объект списка в Group, я буду использовать 9X_c#.net IList и создавать его экземпляр как List.

public class Group { private IList people; public Group() { this.people = new List(); } } 

И, если 9X_c-sharp вам даже не нужно все в IList, вы всегда можете 9X_csharp использовать IEnumerable. С современными компиляторами 9X_visual-c# и процессорами я не думаю, что есть какая-то 9X_.net разница в скорости, так что это скорее вопрос 9X_visual-c# стиля.

Вы должны использовать интерфейс, только 9X_dot-net если он вам нужен, например, если ваш список 9X_.net приводится к реализации IList, отличной 9X_csharp от List. Это верно, например, когда вы используете 9X_csharp NHibernate, который преобразует IList в 9X_.net-framework объект-мешок NHibernate при извлечении данных.

Если 9X_.cs-file List — единственная реализация, которую 9X_.cs-file вы когда-либо будете использовать для определенной 9X_.cs-file коллекции, не стесняйтесь объявлять ее как 9X_.cs-file конкретную реализацию List.

В ситуациях, с которыми я обычно сталкиваюсь, я 9X_.cs-file редко использую IList напрямую.

Обычно я 9X_dot-net просто использую его как аргумент метода

void ProcessArrayData(IList almostAnyTypeOfArray) { // Do some stuff with the IList array } 

Это 9X_c-sharp позволит мне выполнять общую обработку практически 9X_dotnet любого массива в среде .NET, если только 9X_csharp он не использует IEnumerable, а не IList, что 9X_dot-net иногда случается.

Это действительно сводится 9X_c-sharp к той функциональности, которая вам нужна. Я 9X_dotnet бы предложил использовать класс List в большинстве 9X_.net-framework случаев. IList лучше всего подходит, когда 9X_.net вам нужно создать пользовательский массив, который 9X_c#-language может иметь некоторые очень конкретные правила, которые 9X_csharp вы хотели бы инкапсулировать в коллекцию, чтобы 9X_.net не повторяться, но все же хотите, чтобы 9X_.net .NET распознал его как список.

Объект AList позволяет вам создавать список, добавлять 9X_csharp в него элементы, удалять его, обновлять, индексировать 9X_csharp в нем и т. д. Список используется всякий 9X_dot-net раз, когда вам просто нужен общий список, в 9X_.cs-file котором вы указываете тип объекта в нем 9X_.cs-file и все.

С другой стороны, IList - это интерфейс. По 9X_.cs-file сути, если вы хотите создать свой собственный 9X_csharp тип списка, скажем, класс списка с именем 9X_c#.net BookList, тогда вы можете использовать интерфейс, чтобы 9X_visual-c# предоставить вам базовые методы и структуру 9X_c#-language для вашего нового класса. IList предназначен 9X_csharp для тех случаев, когда вы хотите создать 9X_dotnet свой собственный специальный подкласс, реализующий 9X_visual-c# List.

Еще одно отличие: IList - это интерфейс, и 9X_c#.net его нельзя создать. Список - это класс, и 9X_visual-c# его можно создать. Это означает:

IList MyList = new IList(); List MyList = new List