IEnumerable vs List - Що використовувати? Як вони працюють?

У мене є деякі сумніви з приводу того, як працюють переписувачі та LINQ. Розглянемо ці два прості вибір:

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

або

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

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

foreach (Animal animal in sel) { /*do stuff*/ }

1. Я помітив, що якщо я використовую IEnumerable, коли налагоджую і перевіряю "sel", який у даному випадку є IEnumerable, він має кілька цікавих членів: "внутрішній", "зовнішній", "innerKeySelector" і "externalKeySelector", ці останні 2 з'являються бути делегатами. "Внутрішній" член не має в ньому примірників "Тварина", а, наприклад, "Видові" екземпляри, що для мене було дуже дивно. "Зовнішній" член містить екземпляри "Animal". Я припускаю, що два делегати визначають, що входить і що з цього виходить?

2. Я помітив, що якщо я використовую "Розрізнення", "внутрішній" містить 6 елементів (це невірно, оскільки лише 2 - "Відмінність", але "зовнішній" містить правильні значення. Знову ж таки, ймовірно, делеговані методи визначають це, але це трохи більше, ніж я знаю про IEnumerable.

3. Найголовніше, який із двох варіантів є найкращим?

Конвертація злого списку через .ToList()?

Чи, можливо, безпосередньо користуватися перелічником?

Якщо ви можете, будь-ласка, поясніть також трохи або перекиньте кілька посилань, які пояснюють це використання IEnumerable.

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

Щоразу, коли я "укладаю" вирази LINQ, я використовую IEnumerable, тому що, лише уточнюючи поведінку, я даю LINQ можливість відкласти оцінку та, можливо, оптимізувати програму. Пам'ятайте, як LINQ не генерує SQL для запиту бази даних, поки ви не перерахуєте його? Врахуйте це:

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

Тепер у вас є метод, який вибирає початковий зразок ("AllSpotted"), а також деякі фільтри. Отже, тепер ви можете зробити це:

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

Тож чи швидше використовувати List over IEnumerable? Тільки якщо ви хочете запобігти виконанню запиту не один раз. Але чи краще в цілому? Добре у вищесказаному Leopards та Hyenas перетворюються на поодинокі SQL запити , а база даних повертає лише ті релевантні рядки. Але якби ми повернули Список AllSpotted(), то він може працювати повільніше, оскільки база даних може повернути набагато більше даних, ніж насправді потрібно, і ми витрачаємо цикли, здійснюючи фільтрацію в клієнті.

У програмі може бути краще відкласти перетворення запиту до списку до самого кінця, тому, якщо я збираюся перераховувати через Леопарди та Гієни не один раз, я б це зробив:

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

Тут є дуже хороша стаття, яку написав TechBlog Клаудіо Бернасконі: Коли користуватися IEnumerable, ICollection, IList та List

Ось деякі основні моменти щодо сценаріїв та функцій:

Клас, який реалізує, IEnumerableдозволяє використовувати foreachсинтаксис.

В основному він має метод отримати наступний елемент колекції. Йому не потрібно, щоб вся колекція була в пам’яті і не знає, скільки предметів у ній, foreachпросто продовжує отримувати наступний предмет, поки його не закінчиться.

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

Зараз Listреалізує IEnumerable, але представляє всю колекцію в пам'яті. Якщо у вас є IEnumerableі ви телефонуєте, .ToList()ви створюєте новий список із вмістом перерахунку в пам'яті.

Вираз linq повертає перерахунок, і за замовчуванням вираз виконується під час ітерації за допомогою foreach. An IEnumerableвиконується оператор LINQ , коли ви ітеріруете foreach, але ви можете змусити його ітерацію швидше , використовуючи .ToList().

Ось що я маю на увазі:

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

Ніхто не згадав про одну вирішальну різницю, іронічно відповів на запитання, закрите як дублювання цього.

IEumerable є лише для читання, а List - ні.

Див. Практична різниця між List та IEnumerable

Найголовніше, що потрібно усвідомити, це те, що, використовуючи Linq, запит не оцінюється відразу. Він виконується лише як частина ітерації через результат, який IEnumerable<T>виходить в foreach- ось що роблять усі дивні делегати.

Отже, перший приклад оцінює запит негайно, зателефонувавши ToListта поклавши результати запиту в список.
Другий приклад повертає таблицю, IEnumerable<T>яка містить всю інформацію, необхідну для подальшого запуску запиту.

Щодо продуктивності, відповідь - це залежить . Якщо вам потрібно оцінити результати одразу (скажімо, ви мутуєте структури, про які ви запитуєте пізніше, або якщо ви не хочете, щоб ітерація протягом IEnumerable<T>тривала тривалий час), скористайтеся списком. В іншому користуйтеся IEnumerable<T>. За замовчуванням має бути використання оцінки за запитом у другому прикладі, оскільки в цілому використовується менше пам'яті, якщо немає конкретної причини для зберігання результатів у списку.

Перевагою IEnumerable є відкладене виконання (зазвичай з базами даних). Запит не буде виконаний, поки ви фактично не пропустите дані. Це запит, який чекає, поки він не знадобиться (він також лінивий завантаження).

Якщо ви зателефонуєте в ToList, запит буде виконаний, або "матеріалізований", як я хочу сказати.

У обох є плюси і мінуси. Якщо ви зателефонуєте в ToList, ви можете видалити таємницю щодо виконання запиту. Якщо ви дотримуєтесь IEnumerable, ви отримуєте перевагу в тому, що програма не виконує жодних робіт, поки це фактично не потрібно.

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

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));


// updating existing list
names[0] = "ford";

// Guess what should be printed before continuing
print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Очікуваний результат

// I was expecting    
print( startingWith_M.ToList() ); // mercedes, mazda
print( startingWith_F.ToList() ); // fiat, ferrari

Фактичний результат

// what printed actualy   
print( startingWith_M.ToList() ); // mazda
print( startingWith_F.ToList() ); // ford, fiat, ferrari

Пояснення

Відповідно до інших відповідей, оцінка результату була відкладена до виклику ToListабо подібних методів виклику, наприклад ToArray.

Тому я можу переписати код у цьому випадку як:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

// updating existing list
names[0] = "ford";

// before calling ToList directly
var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));

print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

Грайте навколо

https://repl.it/E8Ki/0

Якщо ви хочете лише перелічити їх, скористайтеся IEnumerable.

Однак остерігайтеся, що зміна первісної колекції, яка перераховується, є небезпечною операцією - у цьому випадку вам потрібно ToListспершу. Це створить новий елемент списку для кожного елемента в пам'яті, перерахувавши IEnumerableі, таким чином, менш ефективно, якщо ви перераховуєте лише один раз - але більш безпечні, а іноді Listметоди зручні (наприклад, у випадковому доступі).

Окрім усіх відповідей, розміщених вище, ось мої два центи. Існує багато інших типів, крім List, який реалізує IE Численні такі ICollection, ArrayList і т. Д. Отже, якщо у нас є IEnumerable як параметр будь-якого методу, ми можемо передавати функції будь-яких типів колекції. Тобто ми можемо мати метод для роботи над абстракцією, а не якусь конкретну реалізацію.

Існує багато випадків (наприклад, нескінченний список або дуже великий список), коли IEnumerable не може бути перетворений на Список. Найочевидніші приклади - це всі прості номери, всі користувачі facebook зі своїми реквізитами або всі елементи на ebay.

Різниця полягає в тому, що об’єкти "Список" зберігаються "прямо тут і зараз", тоді як "IEnumeful" об'єкти працюють "лише один за одним". Тож якщо я переглядаю всі предмети на ebay, один за одним буде чимось, з чим навіть малий комп’ютер може впоратися, але ".ToList ()", безумовно, вичерпає мені пам'ять, незалежно від того, наскільки великий мій комп'ютер. Жоден комп’ютер сам по собі не може містити та обробляти таку величезну кількість даних.

[Редагувати] - Потрібно говорити, що це "не те чи те". часто було б доцільно використовувати і список, і IEnumerable в одному класі. Жоден комп’ютер у світі не міг перерахувати всі прості числа, тому що за визначенням це вимагало б нескінченної кількості пам'яті. Але ви можете легко придумати, class PrimeContainerщо містить IEnumerable<long> primes, який із зрозумілих причин також містить SortedList<long> _primes. всі проліки, що розраховані досі. наступний прайм, який слід перевірити, буде виконуватися лише проти існуючих праймерів (до квадратного кореня). Таким чином ви отримуєте обидва - праймери один за одним (IEnumerable) і хороший список "прайменів поки що", що є досить гарним наближенням до всього (нескінченного) списку.