C# లూప్స్ (for, while, do-while, foreach) — సమగ్ర పునరావృతాల గైడ్

1 🔁 కంప్యూటింగ్ ప్రపంచంలో పునరావృతాల శక్తి & CPU సైకిల్స్

ఒక వేరియబుల్‌లోని నంబర్‌ను 1 నుండి 100 వరకు ప్రింట్ చేయడానికి మనం 100 సార్లు Console.WriteLine(1); Console.WriteLine(2); ... అని రాసుకుంటూ వెళ్తే అది కోడ్ కాదు, ఒక డిజాస్టర్! కోడ్ పరిమాణం విపరీతంగా పెరగడమే కాకుండా, దాన్ని భవిష్యత్తులో మార్చడం అసాధ్యం.

లూప్స్ (Loops) అనేవి DRY ప్రిన్సిపల్ (Don't Repeat Yourself) కు ప్రత్యక్ష నిరూపణ. ఒకే కోడ్ బ్లాక్‌ను నిర్దిష్ట షరతు నెరవేరే వరకు పదే పదే ఎగ్జిక్యూట్ చేయడానికి లూప్స్ ఉపయోగపడతాయి.

2 🔄 for లూప్ — కౌంటర్ బేస్డ్ ఇటరేషన్ (The Workhorse)

ఒక పని ఎన్నిసార్లు జరగాలో మనకు ముందే కచ్చితంగా తెలిసినప్పుడు (ఉదాహరణకు: 10 సార్లు లేదా అర్రే పొడవు N సార్లు), for లూప్ అత్యంత సరైన ఎంపిక.

for లూప్ ఒకే లైన్‌లో 3 కీలక భాగాలను కలిగి ఉంటుంది:

1. ఇనిషియలైజేషన్: లూప్ మొదలయ్యే ముందు కేవలం ఒక్కసారి మాత్రమే ఎగ్జిక్యూట్ అవుతుంది (ఉదా: int i = 0;).
2. కండిషన్: ప్రతి రౌండ్ (ఇటరేషన్) ప్రారంభంలో తనిఖీ చేయబడుతుంది. ఇది true అయితేనే లోపలి బాడీ రన్ అవుతుంది, false అయితే లూప్ ఆగిపోతుంది.
3. ఇంక్రిమెంట్/డిక్రిమెంట్: లూప్ బాడీ పూర్తయిన తర్వాత ప్రతిసారీ కౌంటర్ విలువను మారుస్తుంది (ఉదా: i++ లేదా i += 2).

// 1. సాధారణ 1 నుండి 5 వరకు ప్రింట్ చేయడం
for (int i = 1; i <= 5; i++)
{
    Console.WriteLine($"రౌండ్ సంఖ్య: {i}");
}

// 2. మల్టిపుల్ వేరియబుల్స్ ఒకే లూప్ లో (రెండు వైపుల నుండి కౌంటర్ నడపడం)
Console.WriteLine("\nరెండు కౌంటర్లు సమాంతరంగా:");
for (int left = 0, right = 10; left < right; left++, right--)
{
    Console.WriteLine($"Left: {left} <---> Right: {right}");
}

3 ⏳ while లూప్ — ఎంట్రీ-కంట్రోల్డ్ కండిషనల్ ఇటరేషన్

లూప్ ఎన్నిసార్లు తిరగాలో ముందే తెలియక, ఒక నిర్దిష్ట పరిస్థితి లేదా స్థితి (State) మారేంతవరకు తిరగాల్సి వచ్చినప్పుడు while లూప్ వాడాలి.

ఇది ఎంట్రీ-కంట్రోల్డ్ లూప్ (Entry-Controlled Loop). అంటే లోపలికి ప్రవేశించే ముందే షరతును పరీక్షిస్తుంది. మొదటిసారే షరతు అబద్ధమైతే (false), లూప్ బాడీ ఒక్కసారి కూడా రన్ కాదు!

int batteryPercent = 100;

// బ్యాటరీ 20% కంటే ఎక్కువ ఉన్నంతవరకు ఫోన్ నడుస్తుంది
while (batteryPercent > 20)
{
    Console.WriteLine($"🔋 బ్యాటరీ లెవెల్: {batteryPercent}% - ఫోన్ సజావుగా పనిచేస్తోంది.");
    batteryPercent -= 25; // 25% తగ్గుతూ వస్తుంది
}

Console.WriteLine($"⚠️ లో బ్యాటరీ హెచ్చరిక! మిగిలినది: {batteryPercent}%. దయచేసి ఛార్జర్ కనెక్ట్ చేయండి.");

4 🚪 do-while లూప్ — ఎగ్జిట్-కంట్రోల్డ్ (కనీసం ఒక్కసారి గ్యారెంటీ)

కండిషన్ నిజమైనా అబద్ధమైనా సరే — బాడీ కనీసం ఒక్కసారైనా ఖచ్చితంగా ఎగ్జిక్యూట్ అవ్వాలి అనుకున్నప్పుడు do-while లూప్ ఉపయోగిస్తారు.

ఇది ఎగ్జిట్-కంట్రోల్డ్ లూప్ (Exit-Controlled Loop). అంటే కోడ్ బాడీ పూర్తయిన తర్వాత మాత్రమే ఆఖరున షరతును తనిఖీ చేస్తుంది.

నిజ జీవిత ఉదాహరణ: ATM మెషిన్ వద్ద పిన్ అడగడం. యూజర్ సరైన పిన్ కొట్టాడో లేదో తెలియాలంటే మొదట కనీసం ఒక్కసారైనా పిన్ ఎంటర్ చేయమని అడగాలి కదా!

int attempts = 0;
bool isPinCorrect = false;
int dummyInputPin = 1234;

do
{
    attempts++;
    Console.WriteLine($"ప్రయత్నం #{attempts}: దయచేసి మీ 4-అంకెల పిన్ నమోదు చేయండి...");
    
    // అనుకరణ కోసం 3వ ప్రయత్నంలో కరెక్ట్ పిన్ వచ్చింది అనుకుందాం
    if (attempts == 3)
    {
        isPinCorrect = true;
    }
    
} while (!isPinCorrect && attempts < 3);

if (isPinCorrect)
{
    Console.WriteLine("✅ లాగిన్ విజయవంతమైంది! మీ ఖాతా తెరవబడింది.");
}
else
{
    Console.WriteLine("🚨 3 సార్లు తప్పు పిన్ కొట్టారు. కార్డు 24 గంటలు బ్లాక్ చేయబడింది.");
}

సింటాక్స్ గమనిక: do { ... } while (condition); లో చివర తప్పనిసరిగా సెమీకోలన్ (;) ఉండాలి.

5 ⚡ foreach లూప్ & IEnumerable అండర్ ది హుడ్ మెకానిజం

C# లో ఒక అర్రే (Array), లిస్ట్ (List), లేదా ఏదైనా డేటా కలెక్షన్ మీదుగా ప్రయాణించడానికి foreach లూప్ అత్యంత సురక్షితమైన మరియు ప్రజాదరణ పొందిన మార్గం.

ఇక్కడ ఇండెక్స్ i = 0; i < length లాంటి కౌంటర్లతో తలనొప్పి ఉండదు. కలెక్షన్‌లో ఎన్ని వస్తువులు ఉన్నాయో వాటన్నింటినీ మొదటి నుండి చివరి వరకు ఆటోమేటిక్‌గా రీడ్ చేస్తుంది.

string[] programmingLanguages = { "C#", "Python", "Go", "Rust", "TypeScript" };

foreach (string lang in programmingLanguages)
{
    Console.WriteLine($"🚀 నేర్చుకుంటున్న ప్రోగ్రామింగ్ భాష: {lang}");
}

🧠 అండర్ ది హుడ్: C# కంపైలర్ foreach ని ఎలా మార్చుకుంటుంది?

నిజానికి CLR (Common Language Runtime) కి foreach అంటే ఏమిటో నేరుగా తెలియదు! C# కంపైలర్ foreach ను అంతర్గతంగా IEnumerable / IEnumerator మరియు ఒక while లూప్ గా మారుస్తుంది:

// కంపైలర్ సృష్టించే అసలైన అంతర్గత కోడ్ (Decompiled Equivalent):
var enumerator = programmingLanguages.GetEnumerator();
try
{
    while (enumerator.MoveNext())
    {
        string lang = (string)enumerator.Current;
        Console.WriteLine($"లాంగ్వేజ్: {lang}");
    }
}
finally
{
    (enumerator as IDisposable)?.Dispose(); // రిసోర్సెస్ క్లీనప్
}

6 📈 పెర్ఫార్మెన్స్ యుద్ధం: for vs foreach vs Bounds Check Elimination

హై-పెర్ఫార్మెన్స్ సాఫ్ట్‌వేర్ రాసేటప్పుడు "for ఫాస్టా? లేక foreach ఫాస్టా?" అనే చర్చ ఎప్పుడూ నడుస్తూ ఉంటుంది.

• సాధారణ అర్రేస్ (Single-dimensional Arrays): ఆధునిక C# లో సాధారణ అర్రేలపై foreach రాసినా సరే, కంపైలర్ దాన్ని నేరుగా ఆప్టిమైజ్డ్ ఇండెక్స్డ్ for లూప్‌గా మార్చేస్తుంది. కాబట్టి రెండింటి వేగం 100% సమానం!
• JIT Bounds Check Elimination (BCE): ఒకవేళ మీరు for (int i = 0; i < arr.Length; i++) అని రాస్తే, .NET JIT కంపైలర్ అర్రే సైజును గుర్తిస్తుంది. ప్రతి రౌండ్‌లోనూ arr[i] బౌండ్రీ దాటిపోయిందేమో అని చెక్ చేసే ఓవర్‌హెడ్‌ను పూర్తిగా తొలగించేస్తుంది (Bounds Check Elimination).
• List<T> మరియు ఇతరులు: లిస్ట్‌లపై for లూప్ కొద్దిగా వేగంగా పనిచేస్తుంది ఎందుకంటే ఎన్యుమరేటర్ ఆబ్జెక్ట్ క్రియేట్ కాదు.

7 ♾️ ఇన్ఫినిట్ లూప్స్ (Infinite Loops: while true vs for ;;)

ఒక లూప్ ఎప్పటికీ ఆగకుండా నిరంతరం తిరుగుతూ ఉంటే దానిని ఇన్ఫినిట్ లూప్ (Infinite Loop) అంటారు.

ఇది పొరపాటున జరిగితే కంప్యూటర్ CPU ఫ్యాన్ జోరుగా తిరిగి 100% హాంగ్ అయిపోతుంది. కానీ ఉద్దేశపూర్వకంగా ఈ క్రింది సందర్భాలలో ఇన్ఫినిట్ లూప్స్ వాడతారు:

1. ఆపరేటింగ్ సిస్టమ్ కెర్నల్: కంప్యూటర్ ఆఫ్ చేసే వరకు ఓఎస్ రన్ అవుతూనే ఉండాలి.
2. వెబ్ సర్వర్లు (Kestrel / IIS): యూజర్ రిక్వెస్ట్‌ల కోసం 24/7 పోర్ట్ 80/443 పై నిరంతరం వేచి చూడాలి.
3. గేమ్ ఇంజిన్స్ (Unity Update Loop): ప్రతి సెకనుకు ప్లేయర్ మూవ్‌మెంట్స్ విశ్లేషించాలి.

// Style 1: అత్యంత ప్రజాదరణ పొందిన while(true)
int tickCount = 0;
while (true)
{
    tickCount++;
    if (tickCount == 3) break; // రక్షణ బ్రేక్
}

// Style 2: C-స్టైల్ శాశ్వత లూప్ for (;;)
for (;;)
{
    Console.WriteLine("సర్వర్ రన్ అవుతోంది...");
    break; // ఎగ్జిట్
}

8 🧵 మోడ్రన్ C# లో ref foreach & Zero-Copy Iteration

C# 7.3 మరియు 8+ లో మైక్రోసాఫ్ట్ మెమరీ అలోకేషన్స్ తగ్గించడానికి Span<T> మరియు ref readonly foreach లను ప్రవేశపెట్టింది.

భారీ స్ట్రక్ట్స్ (Large Structs) లేదా కోట్ల కొద్దీ డేటా పాయింట్లు ఉన్నప్పుడు, ప్రతి ఐటెమ్‌ను కాపీ చేయకుండా నేరుగా మెమరీ రిఫరెన్స్ ద్వారా లూప్ తిప్పవచ్చు:

Span<int> memoryBlock = stackalloc int[] { 10, 20, 30, 40 };

// జీరో కాపీ ఇటరేషన్: డేటా కాపీ అవ్వదు, కేవలం మెమరీ పాయింటర్ ద్వారా రీడ్ అవుతుంది
foreach (ref readonly var value in memoryBlock)
{
    Console.WriteLine($"మెమరీ విలువ: {value}");
}

9 📊 తులనాత్మక పట్టిక: for vs while vs do-while vs foreach

నాలుగు లూప్‌ల లక్షణాలు మరియు సరిపోయే వినియోగ సందర్భాలు:

10 🎯 ఆధునిక C# లో రేంజ్ (..) మరియు ఇండెక్స్ (^) తో లూపింగ్

C# 8+ లో వచ్చిన Index (^) మరియు Range (..) ఆపరేటర్లు లూప్స్ రాసేటప్పుడు కోడ్‌ను మరింత సంక్షిప్తం చేస్తాయి:

• ^1 అంటే ఆఖరి నుండి మొదటి ఎలిమెంట్ (Last Element).
• 1..^1 అంటే మొదటి మరియు ఆఖరి ఎలిమెంట్లను వదిలేసి మధ్యలో ఉన్నవి మాత్రమే స్లైస్ చేయడం.

string[] auditLog = { "Header", "TXN_01", "TXN_02", "TXN_03", "Footer" };

// Header మరియు Footer వదిలేసి కేవలం ట్రాన్సాక్షన్స్ మాత్రమే ప్రాసెస్ చేయడం:
foreach (var record in auditLog[1..^1])
{
    Console.WriteLine($"ప్రాసెస్ చేస్తున్న రికార్డు: {record}");
}

11 🚀 రియల్-వరల్డ్ ప్రాజెక్ట్: "SIP Wealth Compound Growth & Retirement Simulator"

లూప్స్ (for, while) మరియు కండిషన్స్ ఉపయోగించి — ఒక ఇన్వెస్టర్ ప్రతి నెలా చేసే సిస్టమాటిక్ ఇన్వెస్ట్‌మెంట్ ప్లాన్ (SIP) చక్రవడ్డీతో (Compound Interest) సంవత్సరాల తరబడి ఎలా వృద్ధి చెందుతుందో లెక్కించే ఒక పూర్తి స్థాయి ఫైనాన్షియల్ వెల్త్ సిమ్యులేటర్ ను నిర్మిద్దాం!

using System;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("📈 మన ఇన్వెస్ట్‌మెంట్ - స్మార్ట్ SIP వెల్త్ కాలిక్యులేటర్");
Console.WriteLine("=================================================\n");

// పెట్టుబడి పారామీటర్లు
decimal monthlySip = 10000m;       // ప్రతి నెలా ₹10,000
decimal annualReturnRate = 14.0m;  // ఆశించే సగటు వార్షిక రాబడి 14%
int totalYears = 15;               // 15 సంవత్సరాల పెట్టుబడి

decimal monthlyRate = (annualReturnRate / 100m) / 12m;
int totalMonths = totalYears * 12;

decimal totalInvested = 0m;
decimal currentPortfolioValue = 0m;

Console.WriteLine("సంవత్సరం | పెట్టిన పెట్టుబడి | పోర్ట్‌ఫోలియో సంపద (Compound Value)");
Console.WriteLine("-----------------------------------------------------------------");

// 1. నెలలవారీ చక్రవడ్డీ గణనకు 'for' లూప్
for (int month = 1; month <= totalMonths; month++)
{
    totalInvested += monthlySip;
    
    // ప్రస్తుత సంపదకు నెలవారీ SIP కలపడం + ఆ మొత్తంపై నెలవారీ చక్రవడ్డీ
    currentPortfolioValue = (currentPortfolioValue + monthlySip) * (1m + monthlyRate);
    
    // ప్రతి 12 నెలలకు (ఒక సంవత్సరానికి ఒకసారి) పురోగతి ప్రింట్ చేయడం
    if (month % 12 == 0)
    {
        int year = month / 12;
        Console.WriteLine($"సంవత్సరం {year,2} | ₹{totalInvested,15:N2} | ₹{currentPortfolioValue,22:N2}");
    }
}

decimal totalGains = currentPortfolioValue - totalInvested;
decimal wealthMultiplier = currentPortfolioValue / totalInvested;

// 2. సంపద సారాంశం (Wealth Summary)
Console.WriteLine("-----------------------------------------------------------------");
Console.WriteLine($"మొత్తం పెట్టుబడి కాలం  : {totalYears} సంవత్సరాలు ({totalMonths} నెలలు)");
Console.WriteLine($"జేబు నుండి పెట్టిన మొత్తం: ₹{totalInvested:N2}");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"చక్రవడ్డీ ద్వారా వచ్చిన లాభం: ₹{totalGains:N2}");
Console.WriteLine($"చివరి పోర్ట్‌ఫోలియో విలువ   : ₹{currentPortfolioValue:N2}");
Console.WriteLine($"సంపద పెరిగిన రెట్లు       : {wealthMultiplier:F2}x రెట్లు!");
Console.ResetColor();
Console.WriteLine("=================================================");
Console.WriteLine("క్రమశిక్షణతో కూడిన దీర్ఘకాలిక పెట్టుబడి అపారమైన సంపదను ఇస్తుంది! 🚀\n");

12 🛑 బిగినర్స్ చేసే 7 ఘోరమైన లూప్ తప్పులు

లూప్స్ రాసేటప్పుడు అత్యధికంగా సంభవించే 7 ప్రమాదాలు:

13 🧠 ఇంటరాక్టివ్ సెల్ఫ్-అసెస్మెంట్ క్విజ్ (5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & వివరణలు)

లూప్స్ పై మీ అవగాహనను ఈ 5 ప్రాక్టికల్ ప్రశ్నలతో పరీక్షించుకోండి: