C# switch స్టేట్మెంట్ & మోడ్రన్ switch ఎక్స్ప్రెషన్స్ (=>)
స్వాగతం అధ్యాయం 06 కి! 🔀 బహుళ మార్గాల ఎంపిక & మోడ్రన్ Switch ఎక్స్ప్రెషన్స్ పవర్
గత అధ్యాయంలో మనం if-else కండిషన్లను ఎలా వాడాలో నేర్చుకున్నాం. కానీ ఒక వేరియబుల్కు 10 లేదా 20 రకాల విభిన్న విలువలు వచ్చే అవకాశం ఉన్నప్పుడు (ఉదాహరణకు: వారంలో 7 రోజులు, ట్రాన్సాక్షన్ పేమెంట్ మోడ్లు: UPI, Card, NetBanking, Crypto, Wallet...), పొడవైన if-else-if లాడర్ రాయడం కోడ్ను విపరీతంగా పెంచేస్తుంది మరియు పనితీరును మందగింపజేస్తుంది.
ఇలాంటి బహుళ ఎంపికల సమస్యలకు అసలైన పరిష్కారం switch స్టేట్మెంట్. సాంప్రదాయ C# లో switch-case బ్రేక్లతో కూడిన నిర్మాణం ఉండేది. కానీ C# 8.0 లో వచ్చిన Switch Expressions (=>) ప్రోగ్రామింగ్ ప్రపంచంలో ఒక అద్భుతం! 20 లైన్ల పెద్ద స్విచ్ బ్లాక్ను కేవలం 4 లైన్లలో, ఎంతో అందంగా, లాంబ్డా ఎక్స్ప్రెషన్ తరహాలో మార్చే శక్తిని ఇది అందించింది.
ఈ సమగ్ర 6వ అధ్యాయంలో మనం కంపైలర్ ఇంటర్నల్ జంప్ టేబుల్ (Jump Table) ఆర్కిటెక్చర్, సాంప్రదాయ స్విచ్ నియమాలు, మోడ్రన్ స్విచ్ ఎక్స్ప్రెషన్స్, when గార్డ్ కండిషన్లు, మరియు బహుళ వేరియబుల్స్ను ఏకకాలంలో పరీక్షించే Tuple Patterns ను లోతుగా నేర్చుకొని — ఒక రియల్-వరల్డ్ ఫిన్టెక్ పేమెంట్ రూటింగ్ ఇంజిన్ను నిర్మిస్తాం!
1 🔀 బహుళ మార్గాల ఎంపిక: if-else-if వర్సెస్ switch ఆర్కిటెక్చర్
సాధారణంగా ఒక నిర్ణయం తీసుకోవడానికి if-else-if వాడినప్పుడు, CPU ప్రతి ఒక్క కండిషన్ను క్రమపద్ధతిలో పై నుండి క్రిందికి వరుసగా టెస్ట్ చేస్తుంది (Linear Search - (O(N)) Time Complexity). ఉదాహరణకు 10వ కండిషన్ ట్రూ అయితే, మొదటి 9 కండిషన్లను అనవసరంగా చెక్ చేయాల్సి వస్తుంది.
కానీ switch స్టేట్మెంట్లో కంపైలర్ ఒక అద్భుతమైన ఆప్టిమైజేషన్ చేస్తుంది: జంప్ టేబుల్ (Jump Table / Lookup Table)!
మీరు ఒకే పూర్ణాంకం లేదా ఎన్యూమ్ (Enum) పై 5 కంటే ఎక్కువ కేస్లు రాసినప్పుడు, C# JIT కంపైలర్ ఒక ఇండెక్స్డ్ మెమరీ అడ్రస్ అర్రే (Jump Table) ను సృష్టిస్తుంది. CPU నేరుగా కేస్ విలువ ఆధారంగా సంబంధిత మెమరీ లొకేషన్కు ఒక్క క్లాక్ సైకిల్లోనే దూకుతుంది (Direct Branching)! అంటే 5 కేస్లు ఉన్నా, 100 కేస్లు ఉన్నా ఎగ్జిక్యూషన్ సమయం ఒక్కటే ((O(1)) Constant Time).
2 🏛️ సాంప్రదాయ C# switch-case స్టేట్మెంట్ & Fall-Through రూల్స్
C, C++ లలో ఒక కేస్ చివర break రాయకపోతే కోడ్ దానంతట అదే క్రింది కేస్లోకి జారిపోతుంది (Fall-through). దీనివల్ల చరిత్రలో ఎన్నో ఘోరమైన సాఫ్ట్వేర్ బగ్స్ వచ్చాయి. అందుకే C# డిజైనర్లు దీనిపై కఠినమైన నిబంధన విధించారు: C# లో ప్రతి కేస్ బ్లాక్ చివర తప్పనిసరిగా break, return లేదా throw ఉండాలి!
int dayNumber = 3;
string dayName;
switch (dayNumber)
{
case 1:
dayName = "ఆదివారం (Sunday)";
break;
case 2:
dayName = "సోమవారం (Monday)";
break;
case 3:
dayName = "మంగళవారం (Tuesday)";
break;
case 4:
dayName = "బుధవారం (Wednesday)";
break;
case 5:
dayName = "గురువారం (Thursday)";
break;
case 6:
dayName = "శుక్రవారం (Friday)";
break;
case 7:
dayName = "శనివారం (Saturday)";
break;
default:
dayName = "చెల్లని రోజు సంఖ్య";
break;
}
Console.WriteLine($"రోజు: {dayName}");
మల్టిపుల్ లేబుల్స్ గ్రూపింగ్ (Multiple Case Labels):
కోడ్ లేకుండా కేవలం కేస్ లేబుల్స్ ఒకదాని క్రింద ఒకటి పెడితే C# అనుమతిస్తుంది. బహుళ ఇన్పుట్లకు ఒకే చర్య అవసరమైనప్పుడు ఇది ఎంతో ఉపయోగపడుతుంది:
char grade = 'B';
switch (char.ToUpper(grade))
{
case 'A':
case 'B':
case 'C':
Console.WriteLine("🎉 మీరు పరీక్షలో ఉత్తీర్ణులయ్యారు (Passed)!");
break;
case 'D':
case 'F':
Console.WriteLine("అనుత్తీర్ణులు (Failed). మళ్లీ ప్రయత్నించండి.");
break;
default:
Console.WriteLine("చెల్లని గ్రేడ్ అక్షరం.");
break;
}
3 🚀 గోల్డెన్ ఎరా: మోడ్రన్ C# 8+ switch ఎక్స్ప్రెషన్స్ (=>)
పాత switch స్టేట్మెంట్లో పదే పదే case, :, break; రాయడం చాలా శ్రమతో కూడుకున్నది. C# 8.0 లో మైక్రోసాఫ్ట్ Switch Expression ను పరిచయం చేసింది.
ఇది ఒక స్టేట్మెంట్ (చర్య) కాదు, ఒక ఎక్స్ప్రెషన్ (విలువను రిటర్న్ చేసేది)! కాబట్టి దీని ఫలితాన్ని నేరుగా ఒక వేరియబుల్కు కేటాయించవచ్చు:
int monthNumber = 4;
// మోడ్రన్ C# Fat-Arrow (=>) Switch Expression
string season = monthNumber switch
{
12 or 1 or 2 => "శీతాకాలం (Winter)",
3 or 4 or 5 => "వేసవికాలం (Summer)",
6 or 7 or 8 => "వర్షాకాలం (Monsoon)",
9 or 10 or 11 => "శరదృతువు (Autumn)",
_ => "చెల్లని నెల సంఖ్య"
};
Console.WriteLine($"నెల {monthNumber} సీజన్: {season}");
గమనించండి: ఇక్కడ case లేదు, break లేదు, కోలన్లు లేవు! వేరియబుల్ పేరు ముందు వస్తుంది (monthNumber switch), మరియు ప్రతి ఎంపిక కామా (,) తో వేరు చేయబడుతుంది.
4 🎭 డిస్కార్డ్ ప్యాటర్న్ (_) — ది అల్టిమేట్ డీఫాల్ట్
సాంప్రదాయ స్విచ్లో default: అని రాసినట్లే, మోడ్రన్ స్విచ్ ఎక్స్ప్రెషన్లో అండర్స్కోర్ (_) ని ఉపయోగిస్తారు. దీనిని డిస్కార్డ్ ప్యాటర్న్ (Discard Pattern) అంటారు.
దీని అర్థం: "పైన పేర్కొన్న ఏ ఒక్క కేస్ కూడా మ్యాచ్ కాకపోతే, మిగిలిన ఏ విలువ వచ్చినా సరే ఇక్కడకు రానివ్వు" అని.
మీరు ఒకవేళ _ => ... ని మధ్యలోనే రాస్తే, దాని క్రింద ఉన్న ఏ కేస్ కూడా ఎగ్జిక్యూట్ కాదు (Unreachable Code). కంపైలర్ ఎర్రర్ ఇస్తుంది.
5 🛡️ గార్డ్ షరతులు: when క్లాజ్ (Case Guard Conditions)
ఒక కేస్ కేవలం సమానత్వాన్ని (Equality) మాత్రమే కాకుండా, అదనపు షరతులను కూడా సంతృప్తి పరచాల్సి వచ్చినప్పుడు when క్లాజ్ అద్భుతంగా పనిచేస్తుంది.
decimal transactionAmount = 150000m;
bool isVipCustomer = true;
// when క్లాజ్ తో డైనమిక్ వ్యాపార నిబంధనలు
string approvalAction = transactionAmount switch
{
<= 50000m => "ఆటోమేటిక్ గా ఆమోదించబడింది",
> 50000m and <= 200000m when isVipCustomer => "VIP ప్రివిలేజ్: ప్రత్యేక రుసుము లేకుండా ఆమోదం",
> 50000m and <= 200000m => "OTP మరియు మేనేజర్ ధృవీకరణ అవసరం",
_ => "రిస్క్ అలర్ట్: ఫ్రాడ్ విభాగం మాన్యువల్ రివ్యూ"
};
Console.WriteLine($"లావాదేవీ నిర్ణయం: {approvalAction}");
6 📦 టూపుల్ ప్యాటర్న్స్ (Tuple Pattern Matching in Switch)
నిజ జీవితంలో ఒక నిర్ణయం ఒకే వేరియబుల్ పై ఆధారపడి ఉండదు. రెండు లేదా అంతకంటే ఎక్కువ వేరియబుల్స్ కలయిక (State Combinations) ఆధారంగా నిర్ణయం తీసుకోవాల్సి వస్తుంది.
C# లో Tuple Pattern (var1, var2) switch { ... } ద్వారా బహుళ విలువలను బ్రాకెట్లలో పెట్టి ఒకేసారి స్విచ్ చేయవచ్చు!
string userRole = "Admin";
string requestedAction = "DELETE";
// టూపుల్ ప్యాటర్న్: యూజర్ హోదా మరియు కోరిన చర్య రెండింటినీ ఏకకాలంలో పరీక్షించడం
string accessResult = (userRole, requestedAction) switch
{
("Admin", _) => "పూర్తి అనుమతి లభించింది (Full Admin Access)",
("Editor", "WRITE") => "రాయడానికి అనుమతి ఉంది (Write Approved)",
("Editor", "DELETE") => "తిరస్కరించబడింది: ఎడిటర్లు డేటాను తొలగించలేరు",
("Viewer", "READ") => "చదవడానికి అనుమతి ఉంది (Read-Only)",
(_, _) => "యాక్సెస్ తిరస్కరించబడింది (Unauthorized Access)"
};
Console.WriteLine($"సెక్యూరిటీ గేట్ రిజల్ట్: {accessResult}");
సాంప్రదాయ if-else లో అయితే దీనికి సంక్లిష్టమైన నెస్టెడ్ లాజిక్ రాయాల్సి వచ్చేది. టూపుల్ ప్యాటర్న్ ద్వారా ఇది ఒక స్టేట్ మెషిన్ (State Machine Matrix) లాగా స్పష్టంగా కనిపిస్తుంది.
7 🔍 టైప్ & పొజిషనల్ ప్యాటర్న్స్ (Type Patterns in Switch)
స్విచ్ ఎక్స్ప్రెషన్ ఏదైనా సాధారణ ఆబ్జెక్ట్ (object) ను స్వీకరించి, దాని రన్-టైమ్ టైప్ ఆధారంగా విభిన్న పనులను చేయగలదు.
object payload = 450.75m; // డెసిమల్ డబ్బు లేదా పూర్ణాంకం లేదా టెక్స్ట్ కావచ్చు
string message = payload switch
{
int intVal => $"పూర్ణాంక సంఖ్య: {intVal} (Hex: 0x{intVal:X})",
decimal decVal => $"కరెన్సీ మొత్తం: ₹{decVal:N2}",
string str => $"టెక్స్ట్ సందేశం: {str.Trim()}",
null => "డేటా శూన్యంగా ఉంది (Null Payload)",
_ => "గుర్తించబడని డేటా రకం"
};
Console.WriteLine(message);
8 ⚡ ఎగ్జాస్టివ్ స్విచ్ చెకింగ్ & CS8509 Warning
ఒక ఎన్యూమ్ (Enum) లేదా రకాలపై స్విచ్ రాస్తున్నప్పుడు, మీరు ఏదైనా ఒక కేస్ రాయడం మర్చిపోతే ఆధునిక C# కంపైలర్ మీకు CS8509 Warning ఇస్తుంది: "The switch expression does not handle all possible inputs... It is not exhaustive."
ఒకవేళ రన్టైమ్లో మీరు హ్యాండిల్ చేయని అన్హ్యాండిల్డ్ విలువ వస్తే, C# సైలెంట్గా తప్పు విలువను ఇవ్వకుండా System.Runtime.CompilerServices.SwitchExpressionException ను త్రో చేసి మీ యాప్ను సురక్షితం చేస్తుంది.
పరిష్కారం: ఎల్లప్పుడూ ఆఖరున ఒక డిస్కార్డ్ _ => ... ని ఉంచడం లేదా అన్ని ఎన్యూమ్ విలువలను స్పష్టంగా రాయడం తప్పనిసరి.
9 📊 తులనాత్మక పట్టిక: Classic switch Statement vs Modern switch Expression
ఈ రెండు విభిన్న రూపాల మధ్య సమగ్ర పోలిక:
| ఫీచర్ / కొలమానం | సాంప్రదాయ switch Statement (C# 1 - 7) | మోడ్రన్ switch Expression (C# 8 - 12) |
|---|---|---|
| స్వభావం | Statement (కేవలం పనులు మాత్రమే చేస్తుంది) | Expression (విలువను రిటర్న్ చేస్తుంది) |
| సింటాక్స్ స్టైల్ | switch (x) { case 1: ... break; } |
x switch { 1 => ..., _ => ... }; |
| break కీవర్డ్ | ప్రతి కేస్కు తప్పనిసరి | అసలు అవసరమే లేదు! |
| డీఫాల్ట్ కేస్ | default: ... break; |
డిస్కార్డ్ ఆపరేటర్ _ => ... |
| టూపుల్ ప్యాటర్న్స్ | చాలా కష్టంతో కూడుకున్నది | సహజసిద్ధమైన మద్దతు (a, b) switch |
| కోడ్ పొడవు | చాలా పెద్దది (అధిక బాయిలర్ప్లేట్) | 70% తక్కువ లైన్లలో ముగుస్తుంది |
| ఎగ్జాస్టివ్నెస్ | కంపైలర్ హెచ్చరించదు | పూర్తిగా కవర్ కాకపోతే కంపైలర్ వార్నింగ్ ఇస్తుంది |
10 🚦 అడ్వాన్స్డ్ ప్యాటర్న్ కాంబినేషన్స్ (Relational & Logical inside Switch)
మోడ్రన్ C# లో స్విచ్ ఎక్స్ప్రెషన్స్ లోపల రిలేషనల్ ఆపరేటర్లు (<, >=) మరియు లాజికల్ పదాలు (and, or, not) ను ఒకేచోట మిళితం చేయవచ్చు:
int airQualityIndex = 145; // AQI కాలుష్య సూచిక
string airStatus = airQualityIndex switch
{
<= 50 => "మంచిది (Good - స్వచ్ఛమైన గాలి)",
> 50 and <= 100 => "సంతృప్తికరమైనది (Satisfactory)",
> 100 and <= 200 => "మధ్యస్థ కాలుష్యం (Moderate - సున్నిత వ్యక్తులకు హానికరం)",
> 200 and <= 300 => "ప్రమాదకరం (Poor)",
> 300 and <= 500 => "తీవ్ర ప్రమాదకరం (Severe - మాస్క్ తప్పనిసరి)",
_ => "అసాధారణ రీడింగ్ (సెన్సార్ తనిఖీ చేయండి)"
};
Console.WriteLine($"గాలి నాణ్యత: {airStatus}");
11 🚀 రియల్-వరల్డ్ ప్రాజెక్ట్: "Fintech Multi-Currency Payment Router Engine"
ఈ అధ్యాయంలో నేర్చుకున్న స్విచ్ ఎక్స్ప్రెషన్స్, టూపుల్ ప్యాటర్న్స్, when క్లాజెస్లు ఉపయోగించి — ఒక ప్రొడక్షన్ గ్రేడ్ ఫిన్టెక్ మల్టీ-కరెన్సీ పేమెంట్ గేట్వే రూటింగ్ & ప్రాసెసింగ్ ఇంజిన్ ను తయారు చేద్దాం!
using System;
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("💳 మన ఫిన్టెక్ - గ్లోబల్ పేమెంట్ గేట్వే రూటర్ v1.0");
Console.WriteLine("=================================================\n");
// లావాదేవీ సమాచారం (Transaction Context)
string paymentMethod = "CREDIT_CARD"; // UPI, CREDIT_CARD, NET_BANKING, CRYPTO
string currency = "INR"; // INR, USD, EUR
decimal amount = 25000.00m;
bool isInternational = false;
// 1. గేట్వే రూటింగ్ నిర్ణయం (టూపుల్ స్విచ్ ఎక్స్ప్రెషన్)
string targetGateway = (paymentMethod, currency, isInternational) switch
{
("UPI", "INR", false) => "NPCI-UPI Instant Switch (0% MDR)",
("CREDIT_CARD", "INR", false) => "HDFC / Razorpay Domestic Gateway",
("CREDIT_CARD", _, true) => "Stripe International Multi-Currency Gateway",
("NET_BANKING", "INR", false) => "Direct Bank IMPS/NEFT Engine",
("CRYPTO", _, _) when amount >= 100000m => "Coinbase Enterprise Custody Router",
("CRYPTO", _, _) => "Binance Smart Liquidity Pool",
_ => "Standard Fallback Gateway"
};
// 2. గేట్వే ప్రాసెసింగ్ ఫీజు లెక్కింపు (when క్లాజ్ తో కూడిన స్విచ్)
decimal processingFeePercent = paymentMethod switch
{
"UPI" => 0.0m, // ఉచితం
"CREDIT_CARD" when isInternational => 3.5m, // విదేశీ కార్డులకు 3.5%
"CREDIT_CARD" => 1.75m, // స్వదేశీ కార్డులకు 1.75%
"NET_BANKING" when amount > 10000m => 0.5m,
"NET_BANKING" => 0.0m,
"CRYPTO" => 1.0m,
_ => 2.0m
};
decimal feeAmount = amount * (processingFeePercent / 100m);
decimal finalPayableAmount = amount + feeAmount;
// 3. లావాదేవీ ముగింపు స్టేటస్ మెసేజ్
string statusMessage = targetGateway switch
{
var gw when gw.Contains("NPCI-UPI") => "⚡ క్షణాల్లో పూర్తవుతుంది (Realtime Settlement)",
var gw when gw.Contains("Stripe") => "🌍 విదేశీ మారక ద్రవ్యం వర్తిస్తుంది (Forex Applied)",
var gw when gw.Contains("Enterprise") => "🔐 మల్టీ-సిగ్నేచర్ ఎన్క్రిప్షన్ అవసరం",
_ => "ప్రామాణిక బ్యాంకింగ్ సెటిల్మెంట్ (T+1 Day)"
};
// 4. అధికారిక ట్రాన్సాక్షన్ రసీదు
Console.WriteLine("=================================================");
Console.WriteLine(" లావాదేవీ రూటింగ్ రసీదు ");
Console.WriteLine("=================================================");
Console.WriteLine($"చెల్లింపు విధానం: {paymentMethod}");
Console.WriteLine($"కరెన్సీ రకం : {currency} (అంతర్జాతీయ: {(isInternational ? "అవును" : "కాదు")})");
Console.WriteLine($"అసలు మొత్తం : ₹{amount:N2}");
Console.WriteLine($"ఎంపికైన గేట్వే: {targetGateway}");
Console.WriteLine($"గేట్వే ఫీజు : {processingFeePercent}% (+₹{feeAmount:N2})");
Console.WriteLine("-------------------------------------------------");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"మొత్తం చెల్లించాల్సింది: ₹{finalPayableAmount:N2}");
Console.ResetColor();
Console.WriteLine($"స్థితి సందేశం : {statusMessage}");
Console.WriteLine("=================================================\n");
పేమెంట్ మెథడ్ (UPI, CREDIT_CARD, CRYPTO) మరియు కరెన్సీలను మార్చి గేట్వే రూటింగ్, ఫీజు శాతం ఎలా డైనమిక్గా మారుతున్నాయో బ్రౌజర్ ఎడిటర్లో లైవ్గా చూడండి!
12 🛑 బిగినర్స్ చేసే 7 ఘోరమైన స్విచ్ తప్పులు
స్విచ్ స్టేట్మెంట్లతో పనిచేసేటప్పుడు జూనియర్ డెవలపర్లు ఎదుర్కొనే 7 ప్రమాదాలు:
C# లో ఒక కేస్ లో కోడ్ రాసి break రాయకపోతే కంపైలర్ ఎర్రర్ (CS0163) ఇస్తుంది. Fall-through కి అనుమతి లేదు.
సాధారణ స్విచ్ బ్లాక్ కి సెమీకోలన్ అక్కర్లేదు, కానీ var result = x switch { ... }; అనేది ఒక అసైన్మెంట్ స్టేట్మెంట్ కాబట్టి ఆఖరున తప్పనిసరిగా సెమీకోలన్ ఉండాలి.
డిస్కార్డ్ అన్నింటినీ క్యాచ్ చేస్తుంది కాబట్టి, దాని క్రింద ఉన్న కేస్లు ఎప్పటికీ ఎగ్జిక్యూట్ కావు. డిస్కార్డ్ ఎప్పుడూ ఆఖరు లైన్లోనే ఉండాలి.
డిస్కార్డ్ లేకుండా స్విచ్ ఎక్స్ప్రెషన్ రాస్తే, మ్యాచ్ కాని కొత్త విలువ వచ్చినప్పుడు రన్టైమ్ లో అప్లికేషన్ క్రాష్ అయిపోతుంది.
when i++ > 5 లాంటి మ్యుటేషన్లు రాయకూడదు. ప్యాటర్న్ మ్యాచింగ్ స్వచ్ఛమైన కండిషన్లను మాత్రమే కలిగి ఉండాలి.
పాత switch-case లో డబుల్స్ పై సమానత్వం చెక్ చేయడం ప్రమాదకరం. మోడ్రన్ స్విచ్ లో రిలేషనల్ రేంజ్లను (>= 0.5 and <= 1.0) వాడాలి.
(role, day) స్విచ్ చేసేటప్పుడు కేస్లో ("Monday", "Admin") అని తిరగరాస్తే ఎప్పటికీ మ్యాచ్ కాదు! టూపుల్ ఆర్డర్ సమానంగా ఉండాలి.
13 🧠 ఇంటరాక్టివ్ సెల్ఫ్-అసెస్మెంట్ క్విజ్ (5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & వివరణలు)
స్విచ్ స్టేట్మెంట్లు మరియు మోడ్రన్ స్విచ్ ఎక్స్ప్రెషన్స్పై మీ నైపుణ్యాన్ని ఈ 5 ప్రశ్నలతో పరీక్షించుకోండి:
❓ ప్రశ్న 1: C# JIT కంపైలర్ స్విచ్ స్టేట్మెంట్ను Jump Table గా ఎప్పుడు ఆప్టిమైజ్ చేస్తుంది?
❓ ప్రశ్న 2: Switch Expression లో _ => ... లేకపోతే మరియు ఏ కేస్ మ్యాచ్ కాకపోతే ఏమి జరుగుతుంది?
❓ ప్రశ్న 3: case "Admin": case "SuperAdmin": doWork(); break; అనేది C# లో అనుమతించబడుతుందా?
❓ ప్రశ్న 4: Tuple Pattern Matching (status, code) switch { ... } యొక్క అతిపెద్ద లాభం ఏమిటి?
❓ ప్రశ్న 5: మోడ్రన్ Switch Expression లో when క్లాజ్ ను ఎందుకు ఉపయోగిస్తారు?
when క్లాజ్ ఉపయోగపడుతుంది. ఆ షరతు కూడా నిజమైతేనే సంబంధిత బ్రాంచ్ ఎగ్జిక్యూట్ అవుతుంది.