IEnumerable vs List - что использовать? Как они работают?

IEnumerable описывает поведение, а List является его реализацией. Когда вы используете 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? Только если вы хотите, чтобы запрос не выполнялся более одного раза. Но так ли лучше в целом? В приведенном выше примере Леопарды и Гиены преобразуются в отдельные запросы 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. Оператор 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 ) ...

Никто не упомянул об одном существенном различии, иронически ответил на вопрос, закрытый как дубликат этого.

IEnumerable доступен только для чтения, а 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, которые реализуют IEnumerable, такие как ICollection, ArrayList и т. Д. Итак, если у нас есть IEnumerable в качестве параметра любого метода, мы можем передать функции любые типы коллекций. Т.е. у нас может быть метод для работы с абстракцией, а не с какой-либо конкретной реализацией.

Во многих случаях (например, бесконечный список или очень большой список) IEnumerable не может быть преобразован в список. Наиболее очевидными примерами являются все простые числа, все пользователи facebook с их данными или все товары на ebay.

Разница в том, что объекты «Список» хранятся «прямо здесь и прямо сейчас», тогда как объекты «IEnumerable» работают «только по одному». Так что, если я просматриваю все элементы на ebay, по одному будет то, с чем может справиться даже маленький компьютер, но при использовании ".ToList ()" у меня наверняка не хватит памяти, независимо от того, насколько велик мой компьютер. Ни один компьютер не может сам по себе содержать и обрабатывать такое огромное количество данных.

[Edit] - Что и говорить - это не «ни то, ни то». часто имеет смысл использовать и список, и IEnumerable в одном классе. Ни один компьютер в мире не может перечислить все простые числа, потому что по определению для этого потребуется бесконечное количество памяти. Но вы легко можете подумать о class PrimeContainer, который содержит IEnumerable<long> primes, который по очевидным причинам также содержит SortedList<long> _primes. все простые числа, рассчитанные на данный момент. следующее простое число, которое нужно проверить, будет выполняться только против существующих простых чисел (до квадратного корня). Таким образом вы получаете и то, и другое - простые числа по одному (IEnumerable) и хороший список «простых чисел на данный момент», который является довольно хорошим приближением всего (бесконечного) списка.