ઉકેલી: async ઊંઘ

અસુમેળ પ્રોગ્રામિંગની આજની દુનિયામાં, આપણે ઘણા પડકારોનો સામનો કરીએ છીએ, જેમાંથી એક અસુમેળ રીતે વિલંબ અથવા ઊંઘને ​​નિયંત્રિત કરવાનું છે. સિંક્રનસ પ્રોગ્રામિંગમાં Thread.Sleep() નો ઉપયોગ કરીને ઇરાદાપૂર્વક વિલંબ કરવો એ સામાન્ય પ્રથા છે, પરંતુ અસુમેળ સંદર્ભમાં, અમે Task.Delay() નો ઉપયોગ કરીએ છીએ. સૌપ્રથમ, ચાલો અંદર જઈએ અને સમજીએ કે async અને રાહ ઓપરેટર્સ શું છે અને તેઓ કઈ સમસ્યાનું નિરાકરણ લાવે છે.

એસિંક અને ઓપરેટરોની રાહ જુઓ

C# પાસે છે async અને રાહ જોવી કીવર્ડ્સ કે જે વિકાસકર્તાઓને અસુમેળ કોડ લખવાની મંજૂરી આપે છે જે સિંક્રનસ કોડની જેમ જ દેખાય છે. અસુમેળ પ્રોગ્રામિંગ I/O, નેટવર્ક વિનંતીઓ અથવા ભારે ગણતરીઓ જેવા લાંબા સમયથી ચાલતા ઑપરેશન્સને અવરોધિત કરવા અથવા રાહ જોવાની સમસ્યાઓને હળવી કરે છે, ત્યારબાદ સિસ્ટમની કામગીરીમાં સુધારો કરે છે.

જાહેર async કાર્ય AsyncMethod()
{
બીજી પદ્ધતિની રાહ જુઓ();
}

ઉપરોક્ત પદ્ધતિમાં, જ્યારે કોડ એક્ઝિક્યુટ થાય છે અને રાહ જોઈ રહેલા કીવર્ડ સુધી પહોંચે છે, ત્યારે તે કૉલર પાસે પાછો ફરે છે અને જ્યારે પ્રતીક્ષિત કાર્ય (AnotherMethod()) પૂર્ણ થાય ત્યારે જ આગલી લાઇન પર જાય છે.

સિંક્રનસ સ્લીપ વિ અસિંક્રોનસ વિલંબ

ચાલો Thread.Sleep() અને Task.Delay() વચ્ચેના તફાવતનું અન્વેષણ કરીએ. સિંક્રનસ કોડમાં, જો આપણે કોઈ પદ્ધતિના અમલમાં વિલંબ અથવા થોભાવવા માગીએ છીએ, તો અમે Thread.Sleep() નો ઉપયોગ કરીએ છીએ. જો કે, અસુમેળ દૃશ્યમાં, અમારી પાસે Task.Delay() છે જે 'અસુમેળ ઊંઘ' જેવું કામ કરે છે.

જાહેર રદબાતલ SyncMethod()
{
થ્રેડ.સ્લીપ(1000);
}

જાહેર async કાર્ય AsyncMethod()
{
Task.Delay(1000);
}

સિંક્રનસ પદ્ધતિમાં, જ્યારે 'સ્લીપ' સૂચના હિટ થાય છે, ત્યારે થ્રેડને અવરોધિત કરવામાં આવે છે અને નિર્દિષ્ટ સમય માટે સ્લીપમાં મૂકવામાં આવે છે જે સિસ્ટમની કામગીરી પર નકારાત્મક અસર કરી શકે છે. અસુમેળ પદ્ધતિમાં, જ્યારે 'વિલંબ' સૂચના ચલાવવામાં આવે છે, ત્યારે પદ્ધતિ થોભાવવામાં આવે છે પરંતુ થ્રેડને ફરીથી થ્રેડ પૂલમાં છોડવામાં આવે છે, તેથી ત્યાં કોઈ અવરોધ નથી.

અસુમેળ સ્લીપ પદ્ધતિ બનાવવી

ચાલો અસુમેળ ઊંઘની વિભાવનાને સમજાવતી પદ્ધતિને એકસાથે મૂકીએ. ધ્યાનમાં લો કે અમારી પાસે કેટલીક ગણતરી સઘન પદ્ધતિ છે જેના માટે અમારે વર્તનની મજાક કરવાની જરૂર છે.

પબ્લિક એસિંક ટાસ્ક કોમ્પ્યુટ ઇન્ટેન્સિવ મેથડ()
{
માટે (int i = 0; i < 5; i++) { રાહ જુઓ Task.Delay(2000); Console.WriteLine("વિલંબ પછી એક્ઝેક્યુશન"); } } [/code] ઉપરોક્ત પદ્ધતિમાં, Task.Delay પ્રિન્ટ સ્ટેટમેન્ટના દરેક અમલ પછી 2 સેકન્ડનો અસુમેળ વિલંબ રજૂ કરશે, તેથી અસુમેળ સ્લીપનું અનુકરણ કરશે. અસુમેળ પ્રોગ્રામિંગ પ્રતિભાવશીલ અને કાર્યક્ષમ એપ્લિકેશનો બનાવવા માટે મહત્વપૂર્ણ છે. C# ની અદ્યતન ક્ષમતાઓ જેમ કે async/await અને Task.Delay(), સાથે તમે async પેટર્ન પ્રોગ્રામિંગના લાભને તેની સંપૂર્ણ ક્ષમતા સુધી લઈ શકો છો. યાદ રાખો કે અસુમેળ પ્રોગ્રામિંગ વિશ્વમાં Thread.Sleep ની સરખામણીમાં Task.Delay પદ્ધતિ ઘણી વધુ કાર્યક્ષમ છે, કારણ કે તે વિલંબ કરતી વખતે થ્રેડને અવરોધિત કરતી નથી. આ અધિકારોનો ઉપયોગ કરવાથી તમારી એપ્લિકેશનની કામગીરીમાં નોંધપાત્ર વધારો થઈ શકે છે.