Iterators membolehkan anda menghasilkan urutan nilai secara malas (lazily), satu demi satu, menggunakan kata kunci yield — tanpa membina keseluruhan koleksi dalam memori. Method yang menggunakan yield return menjadi iterator yang menjana nilai atas permintaan, sesuai untuk urutan besar atau tak terhingga dan iterasi tersuai.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return menghasilkan nilai dan menjeda method, menyambung semula dari tempat ia berhenti pada iterasi seterusnya (mengekalkan keadaan). Nilai dijana atas permintaan — tiada apa-apa yang dikira sehingga diminta, dan break menghentikan penjanaan lebih awal.
// ❌ eager — builds the WHOLE list in memory first
public List<int> GetAll(int n)
{
var list = new List<int>();
for (int i = 0; i < n; i++) list.Add(i); // all n values in memory
return list;
}
// ✅ iterator — generates lazily, constant memory regardless of n
public IEnumerable<int> GetAll(int n)
{
for (int i = 0; i < n; i++) yield return i;
}
public IEnumerable<int> Fibonacci()
{
int a = 0, b = 1;
while (true) // infinite — but lazy, so it's fine
{
yield return a;
(a, b) = (b, a + b);
}
}
var first10 = Fibonacci().Take(10); // take only what you need
LINQ's deferred execution is built on iterators — Where/Select use yield internally
to process elements lazily, one at a time, as the result is enumerated.
Iterators dan kata kunci yield ialah ciri C# yang penting untuk penjanaan urutan malas yang cekap-memori, dan memahaminya bernilai untuk memproses set data besar dan untuk memahami bagaimana LINQ berfungsi.
Manfaat teras ialah menghasilkan urutan secara malas, satu nilai pada satu masa, atas permintaan — berbanding membina keseluruhan koleksi dalam memori — yang penting untuk set data besar (di mana memerwujudkan segalanya akan menghabiskan memori), senario penstriman/pemprosesan, dan juga urutan tak terhingga (seperti menjana nombor Fibonacci, mustahil dengan list tetapi remeh dengan iterator malas, mengambil hanya apa yang anda perlukan).
Mekanisme yield return (menghasilkan nilai, menjeda, menyambung semula dengan keadaan dipelihara) menjadikan penulisan penjana malas sedemikian bersih dan semula jadi.
Memahami iterators juga menjelaskan bagaimana deferred execution LINQ berfungsi — operator LINQ menggunakan iterators secara dalaman untuk memproses elemen secara malas semasa hasil dienumerasikan, yang menerangkan tingkah laku malas LINQ.
Mengetahui iterators (penjanaan malas dengan yield, manfaat memori berbanding pembinaan koleksi bersemangat, urutan tak terhingga, dan kaitan dengan deferred execution LINQ) adalah bernilai untuk menulis kod pemprosesan data yang cekap-memori dan untuk memahami model penilaian malas C#.
Walaupun tidak diperlukan untuk setiap senario, iterators adalah penting apabila memproses sejumlah besar data dengan cekap atau membina urutan malas tersuai, dan memahaminya memperdalamkan pemahaman anda tentang LINQ dan penilaian malas — menjadikannya pengetahuan berguna yang relevan secara praktikal untuk C# yang cekap dan topik yang mencerminkan pemahaman tentang keupayaan deferred-execution bahasa.