ઇટરેટર્સ તમને yield કીવર્ડનો ઉપયોગ કરીને એક સમયે આલસીપણે મૂલ્યોનો ક્રમ ઉત્પાદિત કરવા દે છે — સમગ્ર સંગ્રહને મેમરીમાં બાંધ્યા વિના। yield return નો ઉપયોગ કરતી પદ્ધતિ એક ઇટરેટર બની જાય છે જે માંગ પર મૂલ્યો ઉત્પન્ન કરે છે, જે મોટા અથવા અનંત ક્રમ અને કસ્ટમ પુનરાવર્તન માટે આદર્શ છે.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return એક મૂલ્ય ઉત્પાદિત કરે છે અને પદ્ધતિને થોક્યું કરે છે, આગલા પુનરાવર્તન પર તે જ્યાં છોડ્યું હતું ત્યાં પુનઃશરૂ કરે છે (સ્થિતિ સંરક્ષિત રાખે છે). મૂલ્યો માંગ પર ઉત્પન્ન થાય છે — જब સુધી માંગવામાં ન આવે ત્યાં સુધી કંઈ પણ ગણવામાં આવતું નથી, અને break વહેલી રીતે ઉત્પાદન બંધ કરે છે.
// ❌ eager — builds the WHOLE list in memory first
public List<int> GetAll(int n)
{
var list = new List<int>();
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<int> GetAll(int n)
{
for (int i = 0; i < n; i++) yield return i;
}
public IEnumerable<int> 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
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.
ઇટરેટર્સ અને yield કીવર્ડ C# માટે મેમરી-કાર્યક્ષમ, આલસી ક્રમ ઉત્પાદન માટેની મહત્વપૂર્ણ સુવિધાઓ છે, અને તેમને સમજવું મોટા ડેટાસેટ્સ પર પ્રક્રિયા કરવા અને LINQ કેવી રીતે કાર્ય કરે છે તે સમજવા માટે મૂલ્યવાન છે.
મુખ્ય લાભ એ છે કે ક્રમ આલસીપણે, એક સમયે એક મૂલ્ય, માંગ પર ઉત્પાદિત કરવો — સમગ્ર સંગ્રહને મેમરીમાં બાંધ્યા વિને — જે મોટા ડેટાસેટ્સ માટે જરૂરી છે (જ્યાં બધું માટીરીયલાઇજ કરવું મેમરી ખતમ કર્યું), સ્ટ્રીમિંગ/પ્રક્રિયા દૃશ્યો અને અનંત ક્રમો (જેમ કે Fibonacci સંખ્યાઓ ઉત્પન્ન કરવી, લિસ્ટ સાથે અશક્ય પરંતુ આલસી ઇટરેટર સાથે તુચ્છ, માત્ર તમને જોઈતું તે લેવું).
yield return મંત્રવ્યવહાર (મૂલ્ય ઉત્પાદિત કરવો, થોક્યું, સ્થિતિ સંરક્ષિત કરીને પુનઃશરૂ કરવો) આવા આલસી જનરેટર્સ લખવાને સ્વચ્છ અને કુદરતી બનાવે છે.
ઇટરેટર્સને સમજવું LINQ ના આલસી અમલીકરણ કેવી રીતે કાર્ય કરે છે તેને પણ પ્રકાશમાં લાવે છે — LINQ ઓપરેટર્સ આંતરિક રીતે ઇટરેટર્સનો ઉપયોગ કરે છે તત્વોને આલસીપણે પ્રક્રિયા કરવા માટે જેમ પરિણામ પર ગણતરી કરવામાં આવે છે, જે LINQ ના આલસી વર્તનને સમજાવે છે.
ઇટરેટર્સ (આલસી ઉત્પાદન yield સાથે, તત્પર સંગ્રહ-બાંધવા પર મેમરી લાભ, અનંત ક્રમ, અને LINQ ના આલસી અમલીકરણ સાથે જોડાણ) જાણવું મેમરી-કાર્યક્ષમ ડેટા-પ્રક્રિયા કોડ લખવા માટે અને C# ના આલસી મૂલ્યાંકન મોડેલને સમજવા માટે મૂલ્યવાન છે.
હરેક દૃશ્ય માટે જરૂર ન હોય તોપણ, ઇટરેટર્સ મહત્વપૂર્ણ છે જ્યારે મોટા માણસ ડેટા કાર્યક્ષમતાથી પ્રક્રિયા કર્યા અથવા કસ્ટમ આલસી ક્રમો બાંધવા માટે, અને તેમને સમજવું તમારી LINQ અને આલસી મૂલ્યાંકનની સમજણને ઊંડો કરે છે — તેમને કાર્યક્ષમ C# માટે ઉપયોગી, વ્યવહારીક રીતે પ્રસંગિક જ્ઞાન અને ભાષાના આલસી-અમલીકરણ ક્ષમતાઓ સમજવાનો વિષય બનાવે છે.