IEnumerable vs List-czego używać? Jak działają?

Klasa implementująca IEnumerable pozwala na użycie składni foreach.

W zasadzie ma metodę, aby uzyskać następny element w kolekcji. Nie potrzebuje całej kolekcji, aby była w pamięci i nie wie, ile przedmiotów w niej jest, foreach po prostu dostaje następny przedmiot, dopóki się nie skończy.

Może to być bardzo przydatne w pewnych okolicznościach, na przykład w ogromnej tabeli bazy danych nie chcesz skopiować całej rzeczy do pamięci przed rozpoczęciem przetwarzania rzędy.

Teraz List implementuje IEnumerable, ale reprezentuje cały zbiór w pamięci. Jeśli masz IEnumerable i wywołujesz .ToList(), tworzysz nową listę z zawartością wyliczenia w pamięci.

Twoje wyrażenie linq zwraca wyliczenie i domyślnie wyrażenie jest wykonywane podczas iteracji za pomocą foreach. Instrukcja IEnumerable linq jest wykonywana podczas iteracji foreach, ale można ją zmusić do iteracji wcześniej używając .ToList().

Oto co ja średnia:

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 ) ...

Jest bardzo dobry artykuł napisany przez: Claudio Bernasconi TechBlog tutaj: Kiedy używać IEnumerable, ICollection, IList i List

Oto kilka podstawowych punktów o scenariuszach i funkcjach:

Najważniejszą rzeczą do zrealizowania jest to, że używając Linq, zapytanie nie jest natychmiast oceniane. Jest uruchamiany tylko jako część iteracji poprzez wynikowe IEnumerable<T> w foreach - to robią wszyscy dziwni delegaci.

Tak więc pierwszy przykład natychmiast ocenia zapytanie, wywołując ToList i umieszczając wyniki zapytania na liście.
Drugi przykład zwraca IEnumerable<T>, który zawiera wszystkie informacje potrzebne do późniejszego uruchomienia zapytania.

W kategoriach wydajność, odpowiedź brzmi to zależy . Jeśli chcesz, aby wyniki zostały ocenione na raz (powiedzmy, że mutujesz struktury, które pytasz później, lub jeśli nie chcesz, aby iteracja nad IEnumerable<T> trwała długo), Użyj listy. Else use an IEnumerable<T>. Domyślnym rozwiązaniem powinno być użycie oceny na żądanie w drugim przykładzie, ponieważ zwykle zużywa ona mniej pamięci, chyba że istnieje konkretny powód, aby zapisać wyniki na liście.

Nikt nie wspomniał o jednej istotnej różnicy, ironicznie odpowiedział na pytanie zamknięte jako powielone tego.

IEnumerable jest tylko do odczytu, a List Nie.

Zobacz praktyczna różnica między listą a liczbą

Zaletą IEnumerable jest odroczenie wykonania (zwykle z bazami danych). Zapytanie zostanie wykonane dopiero po zapętleniu danych. Jest to zapytanie czekające aż będzie potrzebne (aka leniwe Ładowanie).

Jeśli wywołasz ToList, zapytanie zostanie wykonane, lub "zmaterializowane", jak lubię mówić.

Są plusy i minusy obu. Jeśli zadzwonisz do ToList, możesz usunąć pewną tajemnicę, kiedy zapytanie zostanie wykonane. Jeśli trzymasz się liczby mnogiej, zyskujesz przewagę, że program nie wykonuje żadnej pracy, dopóki nie jest faktycznie wymagany.

Jeśli chcesz tylko je wyliczyć, użyj IEnumerable.

Uważaj jednak, że zmiana oryginalnego zbioru jest niebezpieczną operacją - w tym przypadku będziesz chciał najpierw ToList. Spowoduje to utworzenie nowego elementu listy dla każdego elementu w pamięci, wyliczając IEnumerable i dlatego jest mniej wydajny, jeśli wyliczysz tylko raz - ale bezpieczniejszy i czasami metody List są przydatne (na przykład w dostępie losowym).

Podzielę się jednym błędnym pojęciem, w które wpadłem pewnego dnia:

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() );

Oczekiwany wynik

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

Rzeczywisty wynik

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

Wyjaśnienie

Jak w przypadku innych odpowiedzi, ocena wyniku została odroczona do wywołania ToList lub podobnych metod wywołania, na przykład ToArray.

Więc mogę przepisać kod w tym przypadku jako:

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() );

Zagraj w arround

Https://repl.it/E8Ki/0

Oprócz wszystkich odpowiedzi zamieszczonych powyżej, oto moje dwa grosze. Istnieje wiele innych typów niż Lista, które implementują liczbę takich ICollection, ArrayList itp. Jeśli więc jako parametr dowolnej metody mamy liczbę mnogą, możemy przekazać dowolne typy kolekcji do funkcji. Czyli możemy mieć metodę operowania na abstrakcji, a nie jakąś konkretną implementację.