DEV Community: Myo Zaw Latt

Async ဆိုတာဘယ်လိုမျိုးလဲ

Myo Zaw Latt — Sat, 24 May 2025 03:01:00 +0000

သင်တန်း Page တချို့က Marketing content တွေမှာ Async programming သုံးလိုက်ရင် App တွေကို ပိုမြန်လာစေတယ်ဆိုတာမျိုး ရေးနေတာတွေ့တယ်။ တခုနှစ်ခုမကတော့ဘူးဆိုတော့ လေ့လာနေသူတချို့က ဒါကိုဖတ်မိရင် Async ကို Speed up လုပ်ဖို့ သုံးရတယ်ဆိုတာမျိုး နားလည်မှုလွဲသွားနိုင်တယ်။

Async သုံးလိုက်လို့ ပိုမြန်သွားတာမဟုတ်ဘူးလားဆိုရင်တော့ ဟုတ်ပါတယ်။ ဒါပေမဲ့ Performance efficiency ဖြစ်လို့ ပိုမြန်တာလို့ပြောရလိမ့်မယ်။ သဘောကတော့ ရိုးရိုးတန်းတန်း Synchronous method တခုက တမိနစ်ကြာတယ်ဆိုပါတော့။ Async ပြောင်းလိုက်လို့ စက္ကန့် ၃၀ ဖြစ်မသွားပါဘူး။ တမိနစ်ကြာတဲ့ Task က တမိနစ်ပါဘဲ။ Async သုံးလိုက်လို့ ဘာကွာခြားသွားတာလဲဆိုတော့ အက်သည့်ကြာနေတဲ့ တမိနစ်အတွက် စောင့်နေစရာမလိုဘဲ တခြား Task တခုလုပ်လို့ရသွားတာပါ။ ဒါကို Performance efficiency ဖြစ်တယ်ပြောတာပါ။လဘက်ရည်ဆိုင်တခုမှာ ဝိတ်တာ ဆယ်ယောက်ရှိတယ်ဆိုပါတော့။ ဝိုင်း ၁ က ဝိတ်တာ ၁ ကို စားစရာတခုမှာလိုက်တယ်။ ဝိတ်တာ ၁ က အက်တာကို စားဖိုဆောင်ဆီသွားမှာပြီး စားစရာမပြီးမချင်းထိုင်စောင့်နေပါတယ်။ စားဖိုဆောင်က စားစရာရပြီပြောရင် အက်တာကိုယူလာပြီး ဝိုင်း ၁ ဆီပြန်သွားပေးပါတယ်။ ကြည့်လိုက်ရင် သူမှာလိုက်တဲ့ ဝိတ်တာကဘဲ သူမှာတဲ့စားစရာကို မပြီးမချင်းစောင့်ယူပြီး လာပြန်ပို့ပေးတာပါ။ ဒီပုံစံနဲ့ လည်ပတ်နေတယ်ဆိုရင် ဝိတ်တာ ၁၀ ယောက်ရှိတဲ့အတွက် ဝိုင်း ၁၀ ဝိုင်းအထိ ပြသနာရှိမှာမဟုတ်သေးပါဘူး။ ၁၁ ဝိုင်းမြောက်ကတော့ သူ့ရှေ့က ၁၀ ဝိုင်းထဲက တယောက်လွတ်တဲ့ အထိစောင့်ရမှာပါ။ ပြီးမှ လွတ်တဲ့ ဝိတ်တာကို လိုချင်တာမှာမယ်။ ပြီးရင် မှာတဲ့ဟာမပြီးမချင်းပါ ထပ်စောင့်နေရလို့ ၂ ခါ အချိန်ကုန်တော့မှာပါ။ ဒါဟာ Synchronous programming ရဲ့ အလုပ်လုပ်တဲ့ပုံစံပါ။ တခါ နောက်ပုံစံတမျိုးမှာတော့ ဝိုင်း ၁ က ဝိတ်တာ ၁ ကို စားစရာတခုမှာပြီဆို ဝိတ်တာ ၁ က ဒါကိုစားဖိုဆောင်ဆီပဲ သွားမှာပေးအုံးမှာပါဘဲ။ ဒီတခါတော့ အရင်တခါနဲ့မတူတော့ပါဘူး။ စားဖိုဆောင်ဆီ Schedular တခုပေးခဲ့ပါတယ်။ ဒီစားစရာပြီးရင်တော့ ဝိုင်း ၁ ကို ပို့ပေးပါဆိုတာမျိုးပေါ့။ ဒီတော့ သူက စားစရာမပြီးမချင်း ထိုင်စောင့်နေစရာမလိုတော့ပါဘူး။ တခြားဝိုင်းက ခေါ်တာကိုသွားပေးလို့ရပါပြီ။ စားစရာရပြီဆို စားဖိုဆောင်က ဝိတ်တာ ၁ ပေးခဲ့တဲ့ Schedular အတိုင်းအော်ပေးလိုက်ရင် အားတဲ့ဝိတ်တာက ယူပြီး သက်ဆိုင်ရာ ဝိုင်းကို ပို့ပေးမှာပါ။ ဒီတော့ ဆိုင်မှာ ဝိုင်း ဆန့်သလောက် လူအကုန်လာထိုင်ရင်တောင် ဝိတ်တာတွေကိုမှာဖို့ တဝိုင်းနဲ့ တဝိုင်း စောင့်နေစရာမလိုဘဲ မှာလို့ရသွားမှာပါ။ တခုသတိထားရမှာက အရင်ပုံစံမှာရော နောက်ပုံစံမှာရော စားစရာကို ချက်ပြုတ်နေတဲ့ အချိန်ကတော့ အတူတူပါဘဲ။ ၁၁ ဝိုင်းမြောက်ဟာ ရှေ့က ဝိုင်းတွေကို စောင့်ရတဲ့အချိန် မလိုအပ်တော့တာဘဲ ကွာသွားတာပါ။ ဒါက Asynchronous programming ရဲ့ အလုပ်လုပ်တဲ့ ပုံစံဘဲဖြစ်ပါတယ်။ ဒီနေရာမှာ Speed up ရဲ့ သဘောတရားက Task handling နဲ့ မတူပါဘူး။ ထားပါတော့ ထမင်းကြော်တပွဲကို ၅ မိနစ်လောက်ကြော်နေရရင် ပိုမြန်လာအောင်က ဝိတ်တာတွေကိုမှာတဲ့ပုံစံနဲ့ မဆိုင်ပါဘူး။ စားဖိုခန်းကို အဆင့်မြှင့်ရမှာဖြစ်ပါတယ်။ Async သုံးလိုက်လို့ ပိုမြန်လာမှာ မဟုတ်ဘူးဆိုတာ ဒါကိုပြောတာပါ။

ဒီတော့ ဘာလို့ Async သုံးလိုက်တာနဲ့ ပိုမြန်လာတယ်ထင်ရတာလဲ ဆက်ပြောပြပါမယ်။ ဥပမာ Web server တခုဆိုပါတော့။ Server က တချိန်တည်းမှာ Request 100 ကိုလက်ခံနိုင်ပြီး Sync နဲ့ run နေမယ်ဆိုရင် 101 ခုမြောက် Request ဟာ လေးနေမှာပါ။ လေးတာက Code နဲ့မဆိုင်ပါဘူး။ Server မှာ thread တွေမလွတ်တော့လို့ စောင့်နေရတာပါ။ အဲ Async သုံးတဲ့အခါမှာတော့ အဲတာကို စောင့်မနေရတော့တဲ့အတွက် မြန်မြန်ဆန်ဆန် Handle လုပ်ပြီး Response လုပ်လိုက်မှာပါ။ ဒါက Request ဘက်က ကြည့်ရင် ပိုမြန်သွားတယ်လို့ ခံစားရစေတာပါ။

Async programming ဟာ အင်မတန်အကျိုးများသလို သုံးတတ်ရင်ဆေး မသုံးတတ်ရင်ဘေးပါ။ Async အသုံးကောင်းလို့ Deadlock မိတာတို့ Error ရှာမရတာတို့ ဖြစ်တတ်ပါတယ်။ Async ကို အကျိုးရှိရှိအသုံးချနိုင်ဖို့ဆိုရင် Process, Thread, Thread Pool, TAP, CPU Bound Task, IO Bound Task စတဲ့ အခြေခံသဘောတရားတွေ နားလည်ထားဖို့ လိုအပ်ပါတယ်။ ဒီနေရာမှာတော့ Async အကြောင်း အကျယ်မရေးပြနိုင်ပါဘူး။ အဆင်သင့်တဲ့အခါ ရေးပါမယ်။ အဓိကက Async ဆိုတာ Speed up လုပ်ဖို့သုံးရတာ မဟုတ်ဘူးဆိုတာနဲ့ သူ့ရဲ့ အခြေခံသဘောတရားတခုကို မြင်သာအောင် ဖော်ပြလိုက်ခြင်းဖြစ်ပါတယ်။

IEnumerable, Iteration and Deferred Execution: behind the scenes

Myo Zaw Latt — Sat, 22 Feb 2025 15:02:58 +0000

Programming basic လောက်ကိုသိတဲ့လူတယောက်အဖို့တော့ Array ဆိုတာ သိပ်မစိမ်းတဲ့ Data structure ဖြစ်နေမှာပါ။ C# မှာ Array ကို Access လုပ်ဖို့ Indexing, Looping/Iteration, Linq စသဖြင့် နည်းလမ်းများစွာရှိပါတယ်။ အဲဒီလို Collection-like data structure တွေအတွက်အဓိက အရေးပါတာကတော့ IEnumerable interface ပဲဖြစ်ပါတယ်။ ဒီ Post မှာတော့ C# မှာ Collection data structure တွေအတွက် အဓိက ထောက်ပံ့ပေးထားတဲ့ IEnumerable, IEnumerator နဲ့ Iteration တွေအကြောင်း ပြောပြသွားမှာပါ။

Iteration

Array ကို Access လုပ်ဖို့ မိမိနှစ်သက်တဲ့ Looping ပုံစံကိုသုံးနိုင်ပါတယ်။ ဒါပေမဲ့ ဘယ် Looping style ပဲသုံးသုံး Compiler က while loop အဖြစ်ပြောင်းရေးလိုက်မှာပါ။ ဒီလိုပါ။ ဆိုကြပါစို့။ အောက်မှာ Array တခုတည်ဆောက်ပြီး Looping ပုံစံနှစ်ခုနဲ့ Access လုပ်လိုက်ပါတယ်။

int[] intArray = new int[3];

for (int i = 0; i < intArray.Length; i++)
{

}
foreach (var number in intArray)    
{

}

ဒါကို Compiler က ဒီလိုပြန်ရေးမှာပါ။

// for loop
int[] intArray = new int[3];
int i = 0;
while (i < intArray.Length)
{
     i++;
}

//foreach loop
int[] array = intArray;
int num = 0;
while (num < array.Length)
{
     int number = array [num];
     num++;
}

အခြေခံအားဖြင့် တူညီတဲ့ While looping ပါဘဲ။ ဒါပေမဲ့ ဒီ Array ကိုဘဲ IEnumrable variable ထဲပြောင်းထည့်ပြီး Looping ပြန်ပတ်လိုက်ရင်တော့ ကွဲပြားတဲ့ပုံစံကို တွေ့ရမှာပါ။

IEnumerable  numerated = intArray;
foreach (var number in numerated)
{

}

တခုသတိထားပြီးကြည့်ရင် numerated ဆိုတဲ့ Variable ကို for loop နဲ့ looping ပတ်လို့မရတာကိုတွေ့ရမှာပါ။ ဘာလို့လဲဆိုတော့ သူ့မှာ Computed property မပါတော့လို့ပါ။ အပေါ်က Array မှာတုန်းကတော့ Length property ကို Counter ထားပြီး Loop ကို exit လုပ်နိုင်ပါတယ်။ numerated variable ကို foreach နဲ့ပတ်ထားတဲ့ Looping ကိုတော့ Compiler က ဒီလိုပြန်ရေးမှာပါ။

IEnumerable numerated = intArray;
IEnumerator enumerator = numerated.GetEnumerator();
try
{
     while (enumerator.MoveNext())
     {
          object number2 = enumerator.Current;
     }
}
finally
{
     IDisposable disposable = enumerator as IDisposable;
     if (disposable != null)
     {
          disposable.Dispose();
     }
}

ဒီနေရာမှာ Compiler ပြန်ရေးတဲ့ while loop က ထူးခြားနေတာကိုတွေ့ရမှာပါ။ မူရင်း instance ကနေပြီးတော့ Enumerator object တခုရယူပြီးတော့ အဲဒီ Enumerator မှာရှိတဲ့ MoveNext() method ကို Counter ထားပြီး Loop ပတ်သွားပါတယ်။ ဒါက Iterator pattern ကို အသုံးပြုထားတာဖြစ်ပါတယ်။ နောက်ထပ်ထူးခြားတာကတော့ try-finally block ကိုသုံးထားပြီး Enumerable object ကို Dispose လုပ်ထားတာပါ။

C# မှာရှိတဲ့ Object တိုင်းဟာ Object class က Inherit လုပ်ထားသလိုမျိုးဘဲ Array တိုင်းဟာ Array class ကို Inherit လုပ်ပါတယ်။ ဒါက Language Semantic ဖြစ်ပါတယ်။ ဒီတော့ Array instance တခုဟာ Array class မှာရှိတဲ့ Public method တွေကို ရရှိပါတယ်။ Array class ဟာ IList interface ကို Implement လုပ်ထားပြီး IList interface က IEnumerable interface ကို ICollection interface ကဆင့် inherit လုပ်ထားပါတယ်။ ဒါကြောင့်မလို့ IEnumerable variable ထဲကို Array instance assign လုပ်လို့ရတာပါ။

IEnumerable interface မှာ IEnumerator interface ကို return လုပ်ထားတဲ့ GetEnumerator() ဆိုတဲ့ Method တခုဘဲပါပါတယ်။ IEnumerator interface မှာ MoveNext() နဲ့ Reset() method နှစ်ခုနဲ့ Current ဆိုတဲ့ Read-only property တခုပါပါတယ်။ ဒီ Interface နှစ်ခုက C# ရဲ့ Iterator contract ပါ။

Iterator pattern
Iterator pattern ဆိုတာ နာမည်ကြီး GOF pattern တခုပါဘဲ။ Pattern definition ကတော့ Collection ထဲက Element တွေကို သူ့ရဲ့ဖွဲ့စည်းတည်ဆောက်ပုံကို သိစရာမလိုဘဲ တခုချင်းစီ Access လုပ်နိုင်ဖို့ပါ။ Iterator တခုမှာ Collection ထဲမှာ Element တွေရှိသေးရဲ့လားဆိုတာ စစ်တဲ့ Flag တခုနဲ့ လက်ရှိရောက်နေတဲ့ Element ရနိုင်တဲ့ Property တခုပါရှိရမှာပါ။ Iterable Collection တခုဖြစ်ဖို့ဆိုရင် Iterator တခုအမြဲရှိရမှာဖြစ်ပါတယ်။ ဒါကြောင့်မလို့ C# မှာဆိုရင် IEnumerable interface ဟာ Iterable collection ရစေဖို့အတွက် Iterator ဖြစ်တဲ့ IEnumerator interface ကို contract အနေနဲ့ ထည့်ထားတာဖြစ်ပါတယ်။
ဒီတော့ IEnumerable interface ကို Implement လုပ်ထားတဲ့ Collection တခုရဖို့ ဒီလိုရေးရမှာပါ။

using System.Collections;
class NameCollection : IEnumerable
{
    private readonly string[] _names = { "A name", "B name", "C name" };
    public NameCollection()
    {

    }
    public NameCollection(string[] names)
    {
        _names = names;
    }
    public IEnumerator GetEnumerator()
    {
        return new NameEnumerator(this);
    }

    private class NameEnumerator(NameCollection _nameCollection) : IEnumerator
    {
        private int _position = -1;
        public object Current => _position == -1 || _position >= _nameCollection._names.Length
            ? throw new InvalidOperationException()
            : _nameCollection._names[_position];


        public bool MoveNext()
        {
            _position++;
            return _position < _nameCollection._names.Length;
        }

        public void Reset()
        {
            _position = -1;
        }
    }
}

Client code က ဒါမျိုးဖြစ်မှာပါ။

var names = new NameCollection();
foreach (var name in names)
    Console.WriteLine(name);

var names2 = new NameCollection(["New name 1", "New name 2", "New name 3"]);
var enumearator = names2.GetEnumerator();
while (enumearator.MoveNext())
    Console.WriteLine(enumearator.Current);

အပေါ်က code မှာ storage အနေနဲ့ Array ကိုပဲ backing field အနေနဲ့သုံးထားပါတယ်။ NameCollection ဟာ Looping ပုံစံနှစ်ခုလုံးနဲ့ အလုပ်လုပ်နိုင်တာကိုတွေ့ရမှာပါ။ Enumerable collection တခုကို Access လုပ်ဖို့အတွက် foreach နဲ့ while မှာဆိုရင်တော့ ကျနော့်အနေနဲ့ foreach loop ကိုဘဲရွေးချယ်ဖို့ အကြံပြုပါတယ်။ ဘာလို့လဲဆိုရင် foreach loop က Enumerator ကို Disposable ဖြစ်မဖြစ်စစ်ပေးပြီး တကယ်လို့ Disposable ဖြစ်တဲ့ Enumerator ဆိုရင် finally block ထဲမှာ တခါတည်း Dispose လုပ်ပေးသွားမှာမလို့ပါ။ ဒါကဘာနဲ့တူသလဲဆိုတော့ foreach က using block ကို shadow အနေနဲ့ သုံးပေးထားတာနဲ့တူပါတယ်။ ဒါဟာ Memory safety အတွက်အလွန်ကောင်းပါတယ်။ Disposable enumerator တွေက ဘယ်မှာတွေ့ရတတ်လဲဆိုတော့ System.Collections.Generic namespace အောက်မှာရှိတဲ့ IEnumerator<T> interface ကို implement လုပ်ထားတဲ့ enumerator မှာတွေ့ရပါတယ်။ IEnumerator<T> interface ဟာ IDisposable interface ကို inherit လုပ်ထားတာမလို့ Dispose() method ကိုပါ တခါတည်း Implement လုပ်ပေးရမှာပါ။ ဒီတော့ IEnumerable ကို Implement လုပ်ထားတဲ့ Collection ကို foreach နဲ့ loop ပတ်နိုင်တာဘာကြောင့်လဲ နားလည်လောက်ပြီ ယူဆပါတယ်။ ဒါက C# ရဲ့ Native iteration အကြောင်းပါဘဲ။

Deferred execution

Iterator/Enumerator တခုကို IEnumeartor interface ကို Implement မလုပ်ဘဲ yield statement သုံးပြီး တည်ဆောက်နိုင်ပါတယ်။ အောက်မှာကြည့်ပါ။

using System.Collections;
class NameCollection2 : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        yield return "A name";
        yield return "B name";
        yield return "C name";
    }
}

အပေါ်မှာရေးထားတဲ့ Collection နဲ့ပုံစံတူ Collection တခုကိုရရှိမှာဖြစ်ပါတယ်။ ဒါပေမဲ့ ဒီမှာရရှိလာတဲ့ Enumerator ကတော့ Concrete class instance တခုမဟုတ်ဘဲ Compiler generate လုပ်ပေးလိုက်တဲ့ State machine instance ပဲဖြစ်ပါတယ်။ ဒါကို Lazy evaluation လို့ခေါ်တာပါ။ State machine instance ကို Access လုပ်တဲ့အခါမှာတော့ on-demand execution ပုံစံနဲ့လုပ်ဆောင်ပါတယ်။ Deferred execution လို့လည်းခေါ်ပါတယ်။ ဘယ်လိုပုံစံလဲဆိုတော့ Compiler က yield statement ကိုတွေ့ပြီဆိုတာနဲ့ သက်ဆိုင်ရာလိုအပ်ချက်နဲ့ ကိုက်ညီတဲ့ State machine class တခုကို method နာမည်နဲ့ generate လုပ်ပါတယ်။ အဲဒီ့ class က IEnumerator interface ကို Implement လုပ်ထားပါတယ်။ State machine မှာ Indicator တခုပါပြီးတော့ အဲဒီ Indicator က yield keyword ရှိတဲ့နေရာတိုင်းကိုမှတ်ထားပေးမှာပါ။ MoveNext() method ကိုတခါခေါ်တိုင်း state က တခါပြောင်းသွားပြီး yield statement ကို return လုပ်ပေးမှာပါ။ ပြီးရင်တော့ နောက်မှာရှိတဲ့ yield statement နေရာမှာ နောက်တခါ MoveNext() ကိုမခေါ်မချင်း Pause လုပ်ထားမှာပါ။ နောက်တခါ MoveNext() ကို ထပ်ခေါ်ရင် Pause ထားတဲ့နေရာကနေ ပြန် Run ပေးမှာပါ။ အပေါ်မှာရေးထားတဲ့ GetEnumerator() method အတွက် State machine က ဒီလိုဖြစ်နေမှာပါ (အတိအကျမဟုတ်ပါဘူး မြင်သာအောင်ရေးပြထားတာပါ။ တကယ် Generate လုပ်လိုက်တဲ့ code က ဒီထက်ပိုရှုပ်ထွေးပါတယ်)။

public class GetEnumerator : IEnumerator
{
    private int _state;
    private object _current;
    public GetEnumerator(int state)
    {
        _state = state;
    }
    public bool MoveNext()
    {
        switch (_state)
        {
            case 0:
                _state = -1;
                _current = "A name";
                _state = 1;
                return true;
            case 1:
                _state = -1;
                _current = "B name";
                _state = 2;
                return true;
            case 2:
                _state = -1;
                _current = "C name";
                _state = 3;
                return true;
            default:
                return false;
        }
    }
    public void Reset() => throw new NotSupportedException();
    public object Current => _current;
}

Deferred execution ကိုသုံးခြင်းအားဖြင့် Lazy evaluation ရရှိမှာဖြစ်ပြီးတော့ Performance efficient ဖြစ်စေမှာပါ။ ဥပမာ အောက်ကလို code မျိုးအတွက်ဆိုရင် Deferred execution က တော်တော်လေး သိသာမြင်သာရှိပါတယ်။

foreach (var num in GetNormalList(1000))
    Console.WriteLine(num);

foreach (var num in GetDeferredList(1000))
    Console.WriteLine(num);

int[] GetNormalList(int times)
{
    int[] numList = new int[times];
    for (int i = 0; i < times; i++)
    {
        numList[i] = i;
    }
    return numList;
}
IEnumerable<int> GetDeferredList(int times)
{
    for (int i = 0; i < times; i++)
    {
        yield return i;
    }
    yield break;
}

GetNormalList method မှာဆိုရင် Client code ကနေခေါ်လိုက်တာနဲ့ ပေးထားတဲ့အကြိမ်ရေ မပြည့်မချင်း Loop ပတ်တာကို စောင့်ရမှာဖြစ်ပြီးတော့ ရလာတဲ့ number တွေကို Memory ထဲမှာသိမ်းထားရမှာပါ။ ဒီအတွက် Memory allocation လိုအပ်ပါတယ်။ Method ကို Execute လုပ်ပြီးတာနဲ့ Client code မှာရှိတဲ့ Looping အတိုင်း ဆက်သွားပြီး အကုန်လုံးကို printout လုပ်တာမလို့ Looping နှစ်ထပ်ဖြစ်ပြီး mean time နှစ်ဆ တက်ပါတယ်။ GetDeferredList ကတော့ looping ထဲကနေ printout လုပ်တဲ့နေရာအထိ number တွေကို တိုက်ရိုက် Execute လုပ်တာမလို့ Memory allocation မရှိပါဘူး။ နောက်တခါ yield လုပ်ထားတဲ့တွက်ကြောင့် State machine နဲ့ execute လုပ်တာမလို့ Looping နှစ်ခုဟာ တိုက်ရိုက်ချိတ်ဆက်ပြီး အတူတွဲပြီး ပြီးဆုံးတဲ့အတွက် Mean time လည်းပိုနည်းသွားပါတယ်။ Breakpoint ထောက်ကြည့်လိုက်ရင် ပိုမြင်သာသွားမှာပါ။ ဒီတော့ Deferred execution ကို အသုံးပြုခြင်းအားဖြင့် ပိုမိုကောင်းမွန်တဲ့ Performance ကိုရရှိစေမှာဖြစ်ပါတယ်။ ကန့်သတ်ချက်အနေနဲ့ကတော့ Deferred execution က IEnumerator နဲ့ IEnumerable interface နှစ်ခုနဲ့ဘဲ yield လုပ်နိုင်ပါတယ်။ C# ရဲ့ Best of the best feature တခုဖြစ်တဲ့ Linq မှာတော့ Method chain တွေ အားလုံးဟာ Deferred execution နဲ့ပဲ Implement လုပ်ထားတာဖြစ်ပါတယ်။ ဒီလောက်ဆိုရင်တော့ Deferred execution အကြောင်း သဘောပေါက်လောက်ပြီ ယူဆပါတယ်။

Conclusion

ဒီတော့ အားလုံးကို ခြုံငုံကြည့်မယ်ဆိုရင် IEnumerable interface ဟာ C# ရဲ့ Iterator contract ဖြစ်ပြီး Iteration/Looping တွေဟာ Iterator pattern ကို အသုံးပြုပြီး execute လုပ်တယ်လို့နားလည်ထားရမှာပါ။ IEnumerable နဲ့ IEnumerator interface တွေဟာ Deferred execution ကို Enable လုပ်ပေးထားဖြစ်တဲ့အတွက် Lazy evaluation လိုအပ်ရင် yield statement သုံးပြီးရေးသားနိုင်ပါတယ်။
C# မှာရှိတဲ့ Array တွေအားလုံးကို Array class က Backing ပေးထားတာဖြစ်ပြီးတော့ Array class ဟာ IEnumerable interface ကို Implement လုပ်ထားပါတယ်။ ဒီတော့ C# မှာရှိတဲ့ Array အပါအဝင် Collection Data structure အားလုံးဟာ IEnumerable interface ကို Implement လုပ်ထားတယ်လို့ ယူဆနိုင်ပါတယ်။ IEnumerable, IEnumerator နဲ့ Iterator pattern ကို နားလည်သဘောပေါက်ထားရင် Collection data structure တွေကို ကိုင်တွယ်ရာမှာဘဲ ဖြစ်ဖြစ် ကိုယ်တိုင် တည်ဆောက်ရာမှာဘဲဖြစ်ဖြစ် ပိုပြီးကောင်းမွန်သပ်ရပ်တဲ့ ပုံစံတွေနဲ့ လုပ်ဆောင်နိုင်မှာဖြစ်ပါတယ်။

Thanks for reading, happy coding!