Коли використовувати IList та коли використовувати List

Я знаю, що IList - це інтерфейс, а Список - конкретний тип, але я досі не знаю, коли використовувати їх. Я зараз роблю, якщо мені не потрібні методи Сортування або Знайти всі, я використовую інтерфейс. Маю рацію? Чи є кращий спосіб вирішити, коли використовувати інтерфейс або конкретний тип?

Я дотримуюся двох правил:

• Прийміть найосновніший тип, який буде працювати
• Поверніть найбагатший тип, який вам знадобиться користувачеві

Отже, коли ви пишете функцію чи метод, який бере колекцію, запишіть її не на Список, а на IList <T>, ICollection <T> або IEnumerable <T>. Загальні інтерфейси все ще працюватимуть навіть для гетерогенних списків, оскільки System.Object може бути і T. Це допоможе вам врятувати головний біль, якщо ви вирішите використовувати стек або іншу структуру даних далі вниз. Якщо все, що вам потрібно зробити у функції, - це передбачити її, IEnumerable <T> - це дійсно все, про що ви повинні просити.

З іншого боку, повертаючи об'єкт із функції, ви хочете надати користувачеві найбагатший можливий набір операцій, без того, щоб їх потрібно було виконувати. Тож у такому випадку, якщо це Список <T> внутрішньо, поверніть копію як Список <T>.

Вказівки Майкрософт, як це перевірено FxCop, перешкоджають використанню List <T> у публічних API - віддайте перевагу IList <T>.

Між іншим, я зараз майже завжди оголошую одновимірні масиви як IList <T>, що означає, що я можу послідовно використовувати властивість IList <T> .Count, а не Array.Length. Наприклад:

public interface IMyApi
{
    IList<int> GetReadOnlyValues();
}

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

Є важлива річ, яку люди, здається, завжди не помічають:

Ви можете передати звичайний масив до чогось, що приймає IList<T>параметр, а потім ви можете зателефонувати IList.Add()і отримаєте виняток з виконання:

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

Наприклад, врахуйте наступний код:

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

Якщо ви зателефонуєте так, ви отримаєте виняток із виконання:

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

Це відбувається тому, що використання простих масивів із IList<T>порушенням принципу заміни Ліскова.

З цієї причини, якщо ви телефонуєте, IList<T>.Add()ви можете розглянути питання про необхідність отриманняList<T> а IList<T>.

Я погодився б із порадою Лі щодо прийняття параметрів, але не повернення.

Якщо ви вкажете свої способи повернення інтерфейсу, це означає, що ви можете безкоштовно змінити точну реалізацію пізніше, не використовуючи при цьому споживачий метод. Я думав, що мені ніколи не потрібно буде переходити зі списку <T>, але мені довелося пізніше змінити, щоб використовувати спеціальну бібліотеку списків для додаткової функціональності, яку він надав. Оскільки я лише повернув IList <T>, ніхто з людей, які користувались бібліотекою, не повинен був змінювати свій код.

Зрозуміло, що це стосується лише методів, які є видимими зовні (тобто загальнодоступні методи). Я особисто використовую інтерфейси навіть у внутрішньому коді, але так як ви можете самостійно змінити весь код, якщо внесете неполадки, це зовсім не обов'язково.

IEnumerable
Ви повинні спробувати використовувати найменш конкретний тип, який відповідає вашим цілям.
IEnumerableменш специфічний, ніж IList.
Ви використовуєте, IEnumerableколи хочете переглядати елементи колекції.

IList
IList інвентар IEnumerable.
Ви повинні використовувати, IListколи вам потрібен доступ до колекції за індексом, додавання та видалення елементів тощо ...

Список
List реалізацій IList.

Завжди найкраще використовувати найнижчий можливий базовий тип. Це надає реалізатору вашого інтерфейсу або споживача вашого методу можливість використовувати все, що завгодно, за кадром.

Для колекцій ви повинні прагнути використовувати IEnumerable, де це можливо. Це дає найбільшу гнучкість, але не завжди підходить.

Якщо ви працюєте в рамках одного методу (або навіть в одному класі або в деяких випадках складаєтеся), і ніхто ззовні не збирається бачити, що ви робите, використовуйте повноту Списку. Але якщо ви взаємодієте із зовнішнім кодом, наприклад, коли ви повертаєте список із методу, ви хочете лише оголосити інтерфейс, не обов'язково прив’язуючи себе до конкретної реалізації, особливо якщо ви не маєте контролю над тим, хто компілює ваш код згодом. Якщо ви почали з конкретного типу і вирішили перейти на інший, навіть якщо він використовує той самий інтерфейс, ви збираєтесь порушити чужий код, якщо ви не почали з інтерфейсу або абстрактного базового типу.

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

Наприклад, скажімо, у вас є Personклас та Groupклас. GroupПримірник має багато людей, так що список тут матиме сенс. Коли я декларую об'єкт списку, Groupя буду використовувати IList<Person>та інстанціювати його як List.

public class Group {
  private IList<Person> people;

  public Group() {
    this.people = new List<Person>();
  }
}

І якщо вам навіть все не потрібно, IListви завжди IEnumerableтакож можете використовувати . З сучасними компіляторами та процесорами, я не думаю, що дійсно немає різниці в швидкості, тому це більше лише питання стилю.

Найчастіше краще використовувати найзагальніший користувальницький тип, в цьому випадку IList або ще краще інтерфейс IEnumerable, щоб потім можна було зручніше перемикати реалізацію.

Однак у .NET 2.0 є прикро - у IList немає методу Sort () . Ви можете використовувати адаптер, що постачається в комплекті:

ArrayList.Adapter(list).Sort()

Ви повинні використовувати інтерфейс лише в тому випадку, якщо він вам потрібен, наприклад, якщо ваш список передається для іншої реалізації IList, крім List. Це вірно, коли, наприклад, ви використовуєте NHibernate, який кидає ILists в об'єкт сумки NHibernate під час отримання даних.

Якщо Список є єдиною реалізацією, яку ви коли-небудь використовуватимете для певної колекції, сміливо оголосьте її як конкретну реалізацію списку.

У ситуаціях, які зазвичай трапляються, я рідко використовую IList безпосередньо.

Зазвичай я просто використовую це як аргумент методу

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

Це дозволить мені робити загальну обробку майже на будь-якому масиві .NET Framework, якщо він не використовує IEnumerable, а не IList, що буває іноді.

Це дійсно зводиться до потрібного функціоналу. Я б запропонував використовувати клас List у більшості випадків. IList найкраще, коли вам потрібно створити спеціальний масив, який може містити деякі дуже специфічні правила, які ви хочете інкапсулювати в колекції, щоб ви не повторювали себе, але все ж хочете .NET визнати його списком.

Об'єкт AList дозволяє створювати список, додавати до нього речі, видаляти, оновлювати, індексувати його і т. Д. Список використовується завжди, коли ви просто хочете загальний список, де ви вказуєте його тип об'єкта, і це все.

IList з іншого боку - це інтерфейс. В основному, якщо ви хочете створити свій власний тип списку, скажімо клас списку під назвою BookList, тоді ви можете використовувати Інтерфейс, щоб дати вам основні методи та структуру для нового класу. IList призначений для створення власного спеціального підкласу, який реалізує List.

Ще одна відмінність полягає в тому, що IList - це інтерфейс, і його неможливо створити. Список є класом і може бути екземпляром. Це означає:

IList<string> MyList = new IList<string>();

List<string> MyList = new List<string>