Iterators మరియు yield కీవర్డ్ ఎలా పనిచేస్తాయి?

Question

Accepted Answer

**Iterators** మీరు `yield` కీవర్డ్‌ను ఉపయోగించి ఒక్కసారి ఒక విలువను అలసత్వంగా (lazily) ఉత్పత్తి చేయడానికి అనుమతిస్తాయి — మొత్తం సంగ్రహణను మెమరీలో నిర్మించకుండా। `yield return` ఉపయోగించే పద్ధతి ఒక iterator గా మారుతుంది, ఇది డిమాండ్‌పై విలువలను ఉత్పత్తి చేస్తుంది, ఇది పెద్ద లేదా అనంత శ్రేణులు మరియు కస్టమ్ పునరావృత్తి కోసం ఆదర్శవంతమైనది. ## yield return — అలసత్వ శ్రేణి ఉత్పత్తి ```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` ఒక విలువను ఉత్పత్తి చేస్తుంది మరియు **పాజ్ చేస్తుంది** పద్ధతిని, తరువాతి పునరావృత్తిపై దాని ఎడమ నుండి పుനరారంభిస్తుంది (స్థితిని సంరక్షిస్తుంది). విలువలు **డిమాండ్‌పై** ఉత్పత్తి చేయబడతాయి — అభ్యర్థించే వరకు ఏమీ లెక్కించబడదు, మరియు `break` ఉత్పత్తిని తొందరగా ఆపివేస్తుంది. ## మెమరీ ప్రయోజనం (అలసత్వ వర్సెస్ ఆసక్తి) ```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; } ``` ## అనంత శ్రేణులు (జాబితాతో అసాధ్యం) ```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. ``` ## ఇది ఎందుకు ముఖ్యమైనది Iterators మరియు `yield` కీవర్డ్ **మెమరీ-సమర్థవంతమైన, అలసత్వ శ్రేణి ఉత్పత్తి** కోసం ముఖ్యమైన C# లక్షణాలు, మరియు వాటిని అర్థం చేసుకోవడం పెద్ద డేటాసెట్‌లను ప్రాసెస్ చేయడానికి మరియు LINQ ఎలా పనిచేస్తుందో గ్రహించడానికి విలువైనది. ప్రధాన ప్రయోజనం శ్రేణులను **అలసత్వంగా, ఒక సారి ఒక విలువ, డిమాండ్‌పై** ఉత్పత్తి చేయడం — మెమరీలో సంపూర్ణ సంగ్రహణను నిర్మించడానికి బదులుగా — ఇది పెద్ద డేటాసెట్‌ల కోసం (సమస్తమైన మెటీరియలైజింగ్ మెమరీని అయిపోగా), స్ట్రీమింగ్/ప్రాసెసింగ్ దృశ్యాలు, మరియు **అనంత శ్రేణులు** (ఫిబొనాచ్చీ సంఖ్యలను ఉత్పత్తి చేయటం, జాబితాతో అసాధ్యం కానీ అలసత్వ iterator‌తో చిన్నవిషయం, మీకు కావలసిన దానిని మాత్రమే తీసుకోవడం) ముఖ్యమైనది. `yield return` మెకানిజం (ఒక విలువను ఉత్పత్తి చేయడం, పాజ్ చేయడం, సంరక్షిత స్థితిఫలితంగా పుനరారంభం) అలసత్వ జనరేటర్‌లను వ్రాయడం చేస్తుంది శుభ్రమైనదిగా మరియు సహజమైనదిగా. Iterators ను అర్థం చేసుకోవడం **LINQ యొక్క వాయిదా విధానం ఎలా పనిచేస్తుందో** కూడా వివరిస్తుంది — LINQ సంచాలకారులు elements ను అలసత్వంగా ప్రాసెస్ చేయడానికి internally iterators ను ఉపయోగిస్తారు ఫలితం యొక్క enumerate చేసినప్పుడు, ఇది LINQ యొక్క అలసత్వ ప్రవర్తనను వివరిస్తుంది. Iterators (అలసత్వ ఉత్పత్తి `yield` తో, ఆసక్తి సంగ్రహణ నిర్మాణపై మెమరీ ప్రయోజనాలు, అనంత శ్రేణులు, మరియు LINQ యొక్క వాయిదా విధానకు సంబంధం) తెలుసుకోవడం మెమరీ-సమర్థవంతమైన డేటా-ప్రాసెసింగ్ కోడ్ వ్రాయడానికి విలువైనది మరియు C# యొక్క అలసత్వ మూల్యాంకన నమూనాను అర్థం చేసుకోవడానికి. ప్రతి దృశ్యం కోసం అవసరమైనది కానప్పటికీ, iterators ఎక్కువ డేటాను సమర్థవంతంగా ప్రాసెస్ చేసేటప్పుడు లేదా కస్టమ్ అలసత్వ శ్రేణులను నిర్మించేటప్పుడు ముఖ్యమైనవి, మరియు వాటిని అర్థం చేసుకోవడం LINQ మరియు అలసత్వ మూల్యాంకన యొక్క మీ గ్రహణను లోతుగా చేస్తుంది — సమర్థవంతమైన C# కోసం ఉపయోగకరమైన, ఆచరణాత్మకంగా సంబంధితమైన జ్ఞానం మరియు భాష యొక్క వాయిదా-విధానం సామర్థ్యాల వైపు అవగాహనను ప్రతిబింబించే విషయం.