Iterators საშუალებას გაძლევთ ნიმუშების თანმიმდევრობის ზეწადი წარმოქმნა, ერთი რომელიმე დროს, yield საკვანძო სიტყვის გამოყენებით — მთელი კოლექციის მეხსიერებაში აშენების გარეშე. yield return გამოყენებული მეთოდი ხდება iterator, რომელიც მნიშვნელობებს მოთხოვნის მიხედვით ქმნის, იდეალური დიდი ან უსასრულო მიმდევრობებისა და custom iteration-ის للprocessing-ისთვის.
// a method with `yield return` is an ITERATOR — produces values one at a time
public IEnumerable<int> GetNumbers(int n)
{
for (int i = 0; i < n; i++)
{
yield return i; // produce a value, PAUSE here, resume on the next request
}
}
foreach (var num in GetNumbers(1000000)) // generates lazily — minimal memory
{
Console.WriteLine(num);
if (num > 5) break; // only generated 7 values — the rest were never computed
}
yield return აწვება მნიშვნელობას და ჩერდება მეთოდი, აღმდეგ სმენის შემდეგ თავიდან რომელი დატოვა (მდგომარეობის შესწავლა). მნიშვნელობები ტყოვდება მოთხოვნის მიხედვით — არაფერი არ გამოითვლება მანამ სანამ არ მოითხოვება, და break რომელიმე დროს შეჩერებს წარმოქმნას.
// ❌ 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 და yield საკვანძო სიტყვა მნიშვნელოვანი C# თვისებებია მეხსიერება-ეფექტური, ზეწადი თანმიმდევრობის წარმოქმნის জამოთ, და მათი გაცნობიერება ღირებულია დიდი ან უსასრულო მონაცემთა ნაკრებების დამუშავებისა და LINQ-ის მუშაობის შესაწავლად.
ორი სარგებელი არის თანმიმდევრობის წარმოქმნა ზეწადი, ერთი მნიშვნელობის დროს, მოთხოვნის მიხედვით — სამ მთელი კოლექციის აშენების ნაცვლად მეხსიერებაში — რომელიც აუცილებელია დიდი მონაცემთა ნაკრებებისთვის (სადაც თითოეულის მატერიალიზაცია ამოწურავს მეხსიერებას), streaming/processing მოდელებისა და თუნდაც უსასრულო მიმდევრობებისთვის (როგორი Fibonacci რიცხვების წარმოქმნა, შეუძლებელი სიით მაგრამ მარტივი ზეწადი iterator-ის დროს, მხოლოდ იმას აკმევით რაც გჭირდებათ).
yield return მექანიზმი (მნიშვნელობის აწვება, ჩერება, გაგრძელება დაცულ მდგომარეობით) ხდის ასეთი ზეწადი მწარმოებელიების წერას სისუფთავე და ბუნებრივი.
Iterators-ის გაცნობიერება ასევე ხსნის თუ როგორ LINQ-ის დაჭიანშვილებული შესრულება მუშაობს — LINQ ოპერატორები იყენებენ iterators-ს შიგნით ზეწადი დამუშავებისთვის, რომელიც ხსნის LINQ-ის ზეწადი ქცევას.
Iterators-ის გაცნობიერება (ზეწადი წარმოქმნა yield-ით, მეხსიერების სარგებელი აგრძელებული კოლექციის აშენების ზე, უსასრულო მიმდევრობები, და კავშირი LINQ-ის დაჭიანშვილებული შესრულებასთან) ღირებულია მეხსიერება-ეფექტური მონაცემების დამუშავების კოდი წერის და C#-ის ზეწადი შეფასების მოდელის გაცნობიერებისთვის.
მიუხედავად იმისა რომ არ არის საჭირო თითოეული სცენარისთვის, iterators მნიშვნელოვანია დიდი რაოდენობით მონაცემების ეფექტური დამუშავების ან custom ზეწადი მიმდევრობების აგების დროს, და მათი გაცნობიერება სიღრმისა დასძლევს LINQ და ზეწადი შეფასების — აკეთებს მათ სასარგებო, პრაქტიკული ცოდნას ეფექტური C# და თემა რომელიც ასახავს ენის დაჭიანშვილებული-შესრულების ჯერ მუშაობის გაცნობიერებას.