C# లో async/await ఎలా పని చేస్తుంది?

Question

Accepted Answer

**`async`/`await`** **అసమకాలీన, నాన్-బ్లాకింగ్** కోడ్‌ను సక్షమ చేస్తుంది ఇది సమకాలీన కోడ్‌లా చదువుకోవచ్చు. ఇది I/O-బౌండ్ వర్క్‌కు (డేటాబేస్, నెట్‌వర్క్, ఫైల్ యాక్సెస్) అవసరమైనది — ప్రోగ్రామ్ ఇతర పని చేయడానికి (లేదా అభ్యర్థనలను నిర్వహించడానికి) అనుమతిస్తుంది నెమ్మదిగా ఉన్న ఆపరేషన్‌ల కోసం ఎదురుచూస్తూ, ప్రతిస్పందనశీలత మరియు స్కేలబిలిటీని మెరుగుపరుస్తుంది. ## ప్రాథమిక నమూనా ```csharp public async Task GetDataAsync() // async method returns Task / Task { using var client = new HttpClient(); string result = await client.GetStringAsync(url); // await — non-blocking wait return result; } // calling it string data = await GetDataAsync(); ``` ఒక `async` విధానం `Task` (లేదా `Task`) ను возвращает, మరియు `await` ఆ విధానాన్ని సస్పెండ్ చేస్తుంది అంచనా వేసిన ఆపరేషన్ పూర్తయ్యే వరకు — **థ్రెడ్‌ను బ్లాక్ చేయకుండా**. ఎదురుచూస్తున్నప్పుడు, థ్రెడ్ ఇతర పని చేయడానికి స్వేచ్ఛ చేయబడుతుంది (ఇతర అభ్యర్థనలను నిర్వహించండి, UI ప్రతిస్పందనశీలం ఉంచండి). కోడ్ ఎగువ నుండి క్రిందికి సమకాలీన కోడ్‌లా చదువుకోవచ్చు అసమకాలీన ఉన్నప్పటికీ. ## ఇది ఎందుకు ముఖ్యమైనది: నాన్-బ్లాకింగ్ I/O ```text ❌ synchronous I/O — the thread BLOCKS, doing nothing while waiting (wastes resources) ✅ async I/O — the thread is RELEASED during the wait, serving other work → A web server using async can handle far more concurrent requests with fewer threads. ``` ## ఆపరేషన్‌లను సమానాంతరంగా నడుపుతోంది ```csharp // ❌ sequential — total time = sum of both var a = await GetAAsync(); var b = await GetBAsync(); // ✅ concurrent — start both, then await both (total = max, not sum) Task taskA = GetAAsync(); Task taskB = GetBAsync(); await Task.WhenAll(taskA, taskB); // run independent operations in parallel ``` మల్టిపుల్ స్వతంత్ర ఆపరేషన్‌ల కోసం సమానాంతరంగా ఎదురుచూడటానికి `Task.WhenAll` ఉపయోగించండి — వారు ఒకదానిపై ఒకటి ఆధారపడని ప్రణాళిక పెద్ద వేగం. ## ఉత్తమ పద్ధతులు మరియు ఆపత్తులు ```text ✓ Use async "all the way" — async methods called by async methods ✓ Name async methods with the Async suffix (convention) ✗ AVOID async void (except event handlers) — exceptions are unobservable, can crash ✗ AVOID blocking on async (.Result / .Wait()) — can DEADLOCK; await instead ✓ async is for I/O-bound work; for CPU-bound parallelism use Task.Run / Parallel ``` ## ఇది ఎందుకు ముఖ్యమైనది `async`/`await` ఆధునిక C# లో ఒక ప్రాథమిక, విస్తృతంగా ఉపయోగించే ఫీచర్ — ప్రతిస్పందనశీల, స్కేలబుల్ అప్లికేషన్‌లను నిర్మించడానికి ఆవశ్యకమైనది, కనుక దీన్ని అర్థం చేసుకోవడం ముఖ్యమైనది. ఇది యొక్క ప్రధాన విలువ **నాన్-బ్లాకింగ్ అసమకాలీన I/O** ని సక్షమ చేస్తుంది: I/O-బౌండ్ ఆపరేషన్‌ల కోసం (డేటాబేస్ ప్రశ్నలు, HTTP కాల్‌లు, ఫైల్ యాక్సెస్), `async`/`await` థ్రెడ్‌ను విడుదల చేస్తుంది ఎదురుచూస్తున్నప్పుడు ఇతర పని చేయడానికి, నిష్క్రియంగా నిరోధం చేయడానికి బదులుగా — ఇది స్కేలబిలిటీని నాటకీయంగా మెరుగుపరుస్తుంది (ఒక వెబ్ సర్వర్ ఎక్కువ సమకాలీన అభ్యర్థనలను తక్కువ థ్రెడ్‌లతో నిర్వహించగలదు) మరియు ప్రతిస్పందనశీలత (UIs నెమ్మదిగా ఉన్న ఆపరేషన్ల సమయంలో ప్రతిస్పందనశీలం ఉండండి). ati, ఇది దీన్ని సాధిస్తుంది కోడ్‌ను చదువుకోగలిగినప్పుడు (ఇది సమకాలీన కోడ్‌లా చదువుకోవచ్చు అసమకాలీన ఉన్నప్పటికీ), పాత అసమకాలీన విధానాల కాల్‌బ్యాక్ సంక్లిష్టతను తప్పిస్కోవడం. నమూనాను అర్థం చేసుకోవడం (async విధానాలు `Task`/`Task` ని రిటర్న్ చేస్తాయి, నాన్-బ్లాకింగ్ చేస్తాయి), ఆపరేషన్‌లను **`Task.WhenAll`** తో సమానాంతరంగా నడుపుతోంది (స్వతంత్ర ఆపరేషన్‌ల కోసం ఒక ముఖ్యమైన పనితీరు విజయం), మరియు ముఖ్యంగా **ఆపత్తులు** (async void ని ఇవెంట్ హ్యాండ్లర్‌ల వెలుపల నివారించండి — దాని అంతరాయాలు అనువర్తనాన్ని క్రాష్ చేయవచ్చు; కుడి నుండి సమానాంతర చేయకండి `.Result`/`.Wait()` తో — ఇది డెడ్‌లాక్ చేయవచ్చు; async