iterator และคีย์เวิร์ด yield ทำงานอย่างไร?

Question

Accepted Answer

**Iterator** ช่วยให้คุณผลิตลำดับของค่าแบบ lazy ทีละค่า โดยใช้คีย์เวิร์ด **`yield`** — โดยไม่ต้องสร้าง collection ทั้งหมดในหน่วยความจำ method ที่ใช้ `yield return` จะกลายเป็น iterator ที่สร้างค่าตามต้องการ (on demand) เหมาะอย่างยิ่งสำหรับลำดับขนาดใหญ่หรือไม่จำกัด และการวนซ้ำแบบกำหนดเอง ## yield return — การสร้างลำดับแบบ lazy ```csharp // a method with `yield return` is an ITERATOR — produces values one at a time public IEnumerable 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` ผลิตค่าหนึ่งและ **หยุดชั่วคราว** method นั้น แล้วทำงานต่อจากจุดที่ค้างไว้ในการวนซ้ำครั้งถัดไป (โดยรักษาสถานะไว้) ค่าถูกสร้าง **ตามต้องการ** — ไม่มีอะไรถูกคำนวณจนกว่าจะถูกร้องขอ และ `break` หยุดการสร้างก่อนกำหนด ## ประโยชน์ด้านหน่วยความจำ (lazy กับ eager) ```csharp // ❌ eager — builds the WHOLE list in memory first public List GetAll(int n) { var list = new List(); 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 GetAll(int n) { for (int i = 0; i < n; i++) yield return i; } ``` ## ลำดับไม่จำกัด (เป็นไปไม่ได้ด้วย list) ```csharp public IEnumerable 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 ``` ## yield และ LINQ ```text 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. ``` ## ทำไมจึงสำคัญ Iterator และคีย์เวิร์ด `yield` เป็นฟีเจอร์สำคัญของ C# สำหรับ **การสร้างลำดับแบบ lazy ที่มีประสิทธิภาพด้านหน่วยความจำ** และการเข้าใจมันมีคุณค่าต่อการประมวลผลชุดข้อมูลขนาดใหญ่และต่อการเข้าใจว่า LINQ ทำงานอย่างไร ประโยชน์หลักคือการผลิตลำดับ **แบบ lazy ทีละค่า ตามต้องการ** — แทนที่จะสร้าง collection ทั้งหมดในหน่วยความจำ — ซึ่งจำเป็นสำหรับชุดข้อมูลขนาดใหญ่ (ที่การ materialize ทุกอย่างจะทำให้หน่วยความจำหมด), สถานการณ์ streaming/processing และแม้แต่ **ลำดับไม่จำกัด** (เช่นการสร้างเลข Fibonacci ซึ่งเป็นไปไม่ได้ด้วย list แต่ทำได้ง่ายด้วย lazy iterator โดยเอาเฉพาะเท่าที่ต้องการ) กลไก `yield return` (ผลิตค่า, หยุดชั่วคราว, ทำงานต่อโดยรักษาสถานะไว้) ทำให้การเขียน lazy generator แบบนี้สะอาดและเป็นธรรมชาติ การเข้าใจ iterator ยังช่วยให้เข้าใจว่า **deferred execution ของ LINQ ทำงานอย่างไร** — ตัวดำเนินการของ LINQ ใช้ iterator ภายในเพื่อประมวลผล element แบบ lazy ขณะที่ผลลัพธ์ถูก enumerate ซึ่งอธิบายพฤติกรรมแบบ lazy ของ LINQ การรู้จัก iterator (การสร้างแบบ lazy ด้วย `yield`, ประโยชน์ด้านหน่วยความจำเหนือการสร้าง collection แบบ eager, ลำดับไม่จำกัด และความเชื่อมโยงกับ deferred execution ของ LINQ) มีคุณค่าต่อการเขียนโค้ดประมวลผลข้อมูลที่มีประสิทธิภาพด้านหน่วยความจำและต่อการเข้าใจโมเดล lazy evaluation ของ C# แม้จะไม่จำเป็นสำหรับทุกสถานการณ์ แต่ iterator มีความสำคัญเมื่อประมวลผลข้อมูลปริมาณมากอย่างมีประสิทธิภาพหรือสร้าง lazy sequence แบบกำหนดเอง และการเข้าใจมันทำให้คุณเข้าใจ LINQ และ lazy evaluation ลึกขึ้น — ทำให้เป็นความรู้ที่มีประโยชน์และเกี่ยวข้องในทางปฏิบัติสำหรับ C# ที่มีประสิทธิภาพ และเป็นหัวข้อที่สะท้อนความเข้าใจความสามารถ deferred-execution ของภาษา