IEnumerable vs List - Apa yang Digunakan? Bagaimana mereka bekerja?

Saya memiliki keraguan tentang bagaimana Enumerator bekerja, dan LINQ. Pertimbangkan dua pilihan sederhana ini:

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

atau

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

Saya mengubah nama-nama objek asli saya sehingga ini terlihat seperti contoh yang lebih umum. Permintaan itu sendiri tidak begitu penting. Yang ingin saya tanyakan adalah ini:

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

1. Saya perhatikan bahwa jika saya menggunakan IEnumerable, ketika saya men-debug dan memeriksa "sel", yang dalam hal ini adalah IEnumerable, ia memiliki beberapa anggota yang menarik: "dalam", "luar", "innerKeySelector" dan "outerKeySelector", 2 terakhir ini muncul menjadi delegasi. Anggota "batin" tidak memiliki instance "Hewan" di dalamnya, melainkan instance "Spesies", yang sangat aneh bagi saya. Anggota "luar" memang mengandung instance "Hewan". Saya berasumsi bahwa kedua delegasi menentukan mana yang masuk dan apa yang keluar dari sana?

2. Saya perhatikan bahwa jika saya menggunakan "Distinct", "inner" berisi 6 item (ini tidak benar karena hanya 2 yang Distinct), tetapi "outer" memang mengandung nilai yang benar. Sekali lagi, mungkin metode yang didelegasikan menentukan ini, tetapi ini sedikit lebih dari yang saya tahu tentang IEnumerable.

3. Yang paling penting, yang mana dari dua opsi ini yang terbaik untuk kinerja?

Konversi daftar jahat melalui .ToList()?

Atau mungkin menggunakan enumerator secara langsung?

Jika Anda bisa, tolong jelaskan juga sedikit atau lempar beberapa tautan yang menjelaskan penggunaan IEnumerable ini.

IEnumerablemenggambarkan perilaku, sedangkan Daftar adalah implementasi dari perilaku itu. Ketika Anda menggunakan IEnumerable, Anda memberi kompiler kesempatan untuk menunda pekerjaan sampai nanti, mungkin mengoptimalkan sepanjang jalan. Jika Anda menggunakan ToList (), Anda memaksa kompiler untuk segera memverifikasi hasilnya.

Setiap kali saya "menumpuk" ekspresi LINQ, saya menggunakan IEnumerable, karena dengan hanya menentukan perilaku saya memberi LINQ kesempatan untuk menunda evaluasi dan mungkin mengoptimalkan program. Ingat bagaimana LINQ tidak menghasilkan SQL untuk query database sampai Anda menghitungnya? Pertimbangkan ini:

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;
}

Sekarang Anda memiliki metode yang memilih sampel awal ("AllSpotted"), ditambah beberapa filter. Jadi sekarang Anda bisa melakukan ini:

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

Jadi, apakah lebih cepat menggunakan Daftar IEnumerable? Hanya jika Anda ingin mencegah permintaan dieksekusi lebih dari satu kali. Tapi apakah ini lebih baik secara keseluruhan? Nah di atas, Macan Tutul dan Hyena dapat dikonversi menjadi query SQL tunggal masing-masing , dan database hanya mengembalikan baris yang relevan. Tetapi jika kami telah mengembalikan daftar dari AllSpotted(), maka itu mungkin berjalan lebih lambat karena database dapat mengembalikan data jauh lebih banyak dari yang sebenarnya dibutuhkan, dan kami membuang siklus melakukan penyaringan di klien.

Dalam sebuah program, mungkin lebih baik menunda konversi kueri Anda ke daftar sampai akhir, jadi jika saya akan menghitung melalui Leopards dan Hyenas lebih dari sekali, saya akan melakukan ini:

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

Ada artikel yang sangat bagus yang ditulis oleh: Claudio Bernasconi's TechBlog di sini: Kapan menggunakan IEnumerable, ICollection, IList and List

Di sini beberapa dasar menunjukkan tentang skenario dan fungsi:

Kelas yang mengimplementasikan IEnumerablememungkinkan Anda untuk menggunakan foreachsintaks.

Pada dasarnya ia memiliki metode untuk mendapatkan item berikutnya dalam koleksi. Tidak perlu seluruh koleksi berada di memori dan tidak tahu berapa banyak item di dalamnya, foreachterus dapatkan item berikutnya sampai habis.

Ini bisa sangat berguna dalam keadaan tertentu, misalnya dalam tabel database besar Anda tidak ingin menyalin semuanya ke dalam memori sebelum Anda mulai memproses baris.

Sekarang Listmengimplementasikan IEnumerable, tetapi mewakili seluruh koleksi dalam memori. Jika Anda memiliki IEnumerabledan menelepon, .ToList()Anda membuat daftar baru dengan isi enumerasi dalam memori.

Ekspresi LINQ Anda mengembalikan enumerasi, dan secara default ekspresi dieksekusi ketika Anda beralih menggunakan foreach. Sebuah IEnumerablemengeksekusi pernyataan LINQ ketika Anda iterate foreach, tetapi Anda dapat memaksa untuk iterate lebih cepat menggunakan .ToList().

Inilah yang saya maksud:

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

Tidak ada yang menyebutkan satu perbedaan penting, ironisnya menjawab pertanyaan yang ditutup sebagai duplikat dari ini.

IEnumerable adalah read-only dan List tidak.

Lihat Perbedaan praktis antara Daftar dan IEnumerable

Hal yang paling penting untuk disadari adalah bahwa, menggunakan Linq, permintaan tidak segera dievaluasi. Hal ini hanya dijalankan sebagai bagian dari iterasi melalui dihasilkan IEnumerable<T>dalam foreach- yang ini apa semua delegasi aneh lakukan.

Jadi, contoh pertama mengevaluasi permintaan segera dengan memanggil ToListdan memasukkan hasil permintaan dalam daftar.
Contoh kedua mengembalikan sebuah IEnumerable<T>yang berisi semua informasi yang diperlukan untuk menjalankan kueri nanti.

Dalam hal kinerja, jawabannya tergantung . Jika Anda ingin hasil dievaluasi sekaligus (misalnya, Anda mengubah struktur yang Anda tanyakan nanti, atau jika Anda tidak ingin iterasi lebih IEnumerable<T>lama dari itu) gunakan daftar. Lain gunakan IEnumerable<T>. Defaultnya adalah menggunakan evaluasi sesuai permintaan dalam contoh kedua, karena yang umumnya menggunakan lebih sedikit memori, kecuali ada alasan khusus untuk menyimpan hasil dalam daftar.

Keuntungan dari IEnumerable adalah eksekusi yang ditangguhkan (biasanya dengan database). Permintaan tidak akan dieksekusi sampai Anda benar-benar mengulang data. Ini permintaan menunggu sampai dibutuhkan (alias pemuatan malas).

Jika Anda memanggil ToList, kueri akan dieksekusi, atau "terwujud" seperti yang ingin saya katakan.

Ada pro dan kontra untuk keduanya. Jika Anda memanggil ToList, Anda dapat menghapus beberapa misteri ketika kueri dieksekusi. Jika Anda tetap menggunakan IEnumerable, Anda mendapatkan keuntungan bahwa program tidak melakukan pekerjaan apa pun sampai itu benar-benar diperlukan.

Saya akan membagikan satu konsep yang disalahgunakan yang saya masukkan ke dalam satu hari:

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

Hasil yang diharapkan

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

Hasil yang sebenarnya

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

Penjelasan

Sebagai jawaban lain, evaluasi hasil ditunda sampai memanggil ToListatau metode doa serupa misalnya ToArray.

Jadi saya dapat menulis ulang kode dalam hal ini sebagai:

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

Mainkan di sekeliling

https://repl.it/E8Ki/0

Jika semua yang ingin Anda lakukan adalah menghitungnya, gunakan IEnumerable.

Namun berhati-hatilah bahwa mengubah koleksi asli yang disebutkan adalah operasi yang berbahaya - dalam hal ini, Anda ingin melakukannya ToListterlebih dahulu. Ini akan membuat elemen daftar baru untuk setiap elemen dalam memori, menghitung IEnumerabledan dengan demikian kurang berkinerja jika Anda hanya menghitung satu kali - tetapi lebih aman dan kadang-kadang Listmetode yang berguna (misalnya dalam akses acak).

Selain semua jawaban yang diposting di atas, berikut adalah dua sen saya. Ada banyak tipe lain selain List yang mengimplementasikan IEnumerable seperti ICollection, ArrayList, dll. Jadi jika kita memiliki IEnumerable sebagai parameter dari metode apa pun, kita bisa meneruskan semua tipe koleksi ke fungsi. Yaitu kita dapat memiliki metode untuk beroperasi pada abstraksi bukan implementasi spesifik.

Ada banyak kasus (seperti daftar tak terbatas atau daftar yang sangat besar) di mana IEnumerable tidak dapat diubah menjadi Daftar. Contoh yang paling jelas adalah semua bilangan prima, semua pengguna facebook dengan detailnya, atau semua item di ebay.

Perbedaannya adalah bahwa "Daftar" objek disimpan "di sini dan sekarang", sedangkan "IEnumerable" objek bekerja "hanya satu per satu". Jadi, jika saya memeriksa semua item di ebay, satu per satu akan menjadi sesuatu yang bahkan dapat ditangani oleh komputer kecil, tetapi ".ToList ()" pasti akan membuat saya kehabisan memori, tidak peduli seberapa besar komputer saya. Tidak ada komputer yang dapat dengan sendirinya memuat dan menangani data dalam jumlah sangat besar.

[Sunting] - Tidak perlu dikatakan - itu bukan "ini atau itu". seringkali masuk akal untuk menggunakan daftar dan IEnumerable di kelas yang sama. Tidak ada komputer di dunia yang dapat mendaftar semua bilangan prima, karena menurut definisi ini akan membutuhkan jumlah memori yang tak terbatas. Tetapi Anda dapat dengan mudah memikirkan class PrimeContaineryang berisi IEnumerable<long> primes, yang karena alasan yang jelas juga mengandung SortedList<long> _primes. semua bilangan prima dihitung sejauh ini. perdana berikutnya yang akan diperiksa hanya akan dijalankan terhadap bilangan prima yang ada (hingga akar kuadrat). Dengan begitu Anda memperoleh keduanya - bilangan prima satu per satu (IEnumerable) dan daftar "bilangan prima sejauh ini" yang bagus, yang merupakan perkiraan yang cukup bagus dari seluruh daftar (tak terbatas).