C# కండిషనల్ స్టేట్మెంట్స్ (if-else) & మోడ్రన్ Pattern Matching
స్వాగతం Phase 02 కి! 🚦 కోడ్ నిర్ణయాధికారం & ఆధునిక Pattern Matching విప్లవం
ఇప్పటివరకు మనం నేర్చుకున్న ప్రోగ్రామ్లు కేవలం పై నుండి క్రిందికి వరుసగా (Line-by-Line) ఎగ్జిక్యూట్ అయ్యే సాధారణ కాలిక్యులేషన్స్ మాత్రమే. కానీ నిజమైన ప్రపంచంలో సాఫ్ట్వేర్ అనేది పరిస్థితులకు అనుగుణంగా స్వంతంగా నిర్ణయాలు తీసుకోగలగాలి! ఉదాహరణకు: వినియోగదారుడు బ్యాంక్ ఖాతాలో బ్యాలెన్స్ కంటే ఎక్కువ డబ్బు విత్డ్రా చేయడానికి ప్రయత్నిస్తే నిరాకరించాలి; అర్ధరాత్రి క్రెడిట్ కార్డుపై అనుమానాస్పద లావాదేవీ జరిగితే బ్లాక్ చేయాలి.
ఈ నిర్ణయాధికార ప్రక్రియను కంప్యూటర్ సైన్స్లో కంట్రోల్ ఫ్లో (Control Flow) లేదా బ్రాంచింగ్ (Branching) అంటారు. సాంప్రదాయ C, C++, జావా భాషల్లో మనం దశాబ్దాలుగా వాడిన if-else నిబంధనలు C# లో కూడా ఉన్నప్పటికీ — ఆధునిక C# (C# 9 నుండి C# 12 వరకు) లో ప్రవేశపెట్టబడిన Pattern Matching ప్రోగ్రామింగ్ శైలినే సమూలంగా మార్చేసింది!
ఈ అధ్యాయంలో మనం సాంప్రదాయ if-else యొక్క అంతర్గత పనితీరు, ప్రొఫెషనల్ ఆర్కిటెక్ట్స్ వాడే గార్డ్ క్లాజ్ (Guard Clause) టెక్నిక్, మరియు C# లోని విప్లవాత్మక is, and, or, not మరియు ప్రాపర్టీ ప్యాటర్న్స్ ను క్షుణ్ణంగా పరిశీలించి — ఒక బ్యాంకింగ్ లోన్ అండర్రైటింగ్ ఇంజిన్ను నిర్మిస్తాం!
1 🚦 ప్రోగ్రామింగ్ లో నిర్ణయాధికారం & CPU బ్రాంచ్ ప్రిడిక్షన్
ఒక ప్రోగ్రామ్ ఎగ్జిక్యూట్ అవుతున్నప్పుడు CPU ఇన్స్ట్రక్షన్ పాయింటర్ (Instruction Pointer) సాధారణంగా తదుపరి లైన్ వైపు వెళ్తుంది. కానీ ఒక కండిషనల్ స్టేట్మెంట్ (if) ఎదురైనప్పుడు, కంప్యూటర్ ఒక కూడలి (Crossroads) కి చేరుకుంటుంది: కండిషన్ true అయితే ఒక రోడ్డులోకి, false అయితే మరొక రోడ్డులోకి కోడ్ ప్రవాహం మళ్లుతుంది.
ఆధునిక ప్రాసెసర్లు (Intel Core, AMD Ryzen, Apple Silicon) చాలా వేగంగా ఉంటాయి. అవి if కండిషన్ రిజల్ట్ తేలే వరకు వేచి ఉండవు! ముందే ఊహించి (Speculative Execution) ఒక రోడ్డు వైపు ఇన్స్ట్రక్షన్లను ప్రీ-ఫెచ్ చేస్తాయి. ఒకవేళ CPU ఊహ తప్పు అని తెలిస్తే (Branch Misprediction), అది పైప్లైన్లోని మొత్తం పనులను రద్దు చేసి మళ్లీ మొదటికి రావాల్సి వస్తుంది (10 నుండి 20 CPU క్లాక్ సైకిల్స్ వృధా అవుతాయి). అందుకే ప్రొఫెషనల్ సాఫ్ట్వేర్లో క్లీన్ మరియు ప్రిడిక్టబుల్ కండిషన్స్ రాయడం చాలా ముఖ్యం.
C# లో కండిషనల్ స్టేట్మెంట్ ఎప్పుడూ ఒక bool ఎక్స్ప్రెషన్ ను మాత్రమే స్వీకరిస్తుంది. C లాంగ్వేజ్లో లాగా if (1) లేదా if (500) అని పూర్ణాంకాలను రాయడానికి C# లో అనుమతి లేదు. ఖచ్చితంగా if (count > 0) లేదా if (isValid) వంటి నిజమైన బూలియన్ మాత్రమే ఉండాలి.
2 🔀 బేసిక్ if, if-else మరియు if-else-if లాడర్
నిర్ణయాలు తీసుకోవడానికి C# లో ప్రాథమికంగా 3 రూపాలు ఉన్నాయి:
1. కేవలం if (సింగిల్ ఛాయిస్)
షరతు నిజమైతేనే లోపలి కోడ్ రన్ అవుతుంది, అబద్ధమైతే ఏమీ చేయకుండా ముందుకు సాగిపోతుంది.
2. if-else (ద్వంద్వ ఛాయిస్ - True or False)
షరతు నిజమైతే if బ్లాక్, అబద్ధమైతే తప్పనిసరిగా else బ్లాక్ రన్ అవుతుంది. రెండింటిలో ఏదో ఒకటి మాత్రమే ఖచ్చితంగా రన్ అవుతుంది.
3. if-else-if Ladder (బహుళ ఎంపికలు)
వరుసగా పలు షరతులను పై నుండి క్రిందికి తనిఖీ చేస్తూ వెళ్తుంది. ఏ ఒక్క షరతు మొదటగా true అవుతుందో ఆ బ్లాక్ ఎగ్జిక్యూట్ అయి వెంటనే మొత్తం లాడర్ నుండి బయటకు వచ్చేస్తుంది. మిగిలిన షరతులను పరీక్షించదు.
int studentScore = 82;
string grade;
if (studentScore >= 90)
{
grade = "A+ (అత్యుత్తమ ప్రతిభ)";
}
else if (studentScore >= 75)
{
grade = "A (డిస్టింక్షన్)"; // ఇక్కడ 82 ఉంది కాబట్టి ఇది మాత్రమే రన్ అవుతుంది!
}
else if (studentScore >= 60)
{
grade = "B (ఫస్ట్ క్లాస్)";
}
else if (studentScore >= 35)
{
grade = "C (పాస్)";
}
else
{
grade = "F (రీ-అప్పియర్)";
}
Console.WriteLine($"విద్యార్థి గ్రేడ్: {grade}");
ఒకే ఒక లైన్ కోడ్ ఉన్నప్పుడు కర్లీ బ్రాకెట్లు {} పెట్టకపోయినా కంపైల్ అవుతుంది. కానీ నెస్టెడ్ కండిషన్లలో else ఏ if కి చెందుతుందో అర్థం కాక తీవ్రమైన లాజిక్ బగ్స్ వస్తాయి. కాబట్టి ఒక్క లైన్ ఉన్నప్పటికీ ఎల్లప్పుడూ కర్లీ బ్రాకెట్లు {} వాడటం ప్రొఫెషనల్ నిబంధన!
3 🪺 నెస్టెడ్ if-else & ది పిరమిడ్ ఆఫ్ డూమ్ (Pyramid of Doom)
ఒక if బ్లాక్ లోపల మరొక if, దాని లోపల ఇంకొక if రాసుకుంటూ పోవడాన్ని నెస్టెడ్ కండిషన్స్ (Nested Conditions) అంటారు.
ఇది సాధారణ సమస్యలకు పనిచేసినప్పటికీ, నిజమైన ప్రాజెక్ట్లలో కోడ్ కుడివైపుకి బాణం ఆకారంలో (Arrow Shape) లేదా పిరమిడ్ లాగా విస్తరిస్తూ పోతుంది. దీనినే ఇండస్ట్రీలో "Pyramid of Doom" లేదా "Arrow Anti-pattern" అంటారు.
// ❌ చెడ్డ కోడ్: లోతుగా నెస్టెడ్ అయి చదవడానికి నరకంలా ఉంటుంది
void ProcessWithdrawalBad(decimal balance, decimal amount, bool isCardActive, bool isPinValid)
{
if (isCardActive)
{
if (isPinValid)
{
if (amount > 0)
{
if (balance >= amount)
{
Console.WriteLine("నగదు విత్డ్రా విజయవంతమైంది!");
}
else
{
Console.WriteLine("ఖాతాలో సరిపడా నిధులు లేవు.");
}
}
else
{
Console.WriteLine("చెల్లని మొత్తం.");
}
}
else
{
Console.WriteLine("తప్పుడు పిన్ నంబర్.");
}
}
else
{
Console.WriteLine("కార్డు బ్లాక్ చేయబడింది.");
}
}
ఇటువంటి కోడ్ను అర్థం చేసుకోవడం, బగ్స్ ఫిక్స్ చేయడం మరియు యూనిట్ టెస్ట్లు రాయడం చాలా కష్టం. దీనిని ప్రొఫెషనల్ సాఫ్ట్వేర్ ఇంజనీర్లు ఎలా పరిష్కరిస్తారో తర్వాతి సెక్షన్లో చూద్దాం!
4 🛡️ గార్డ్ క్లాజ్ టెక్నిక్ (Guard Clauses / Early Return Pattern)
సీనియర్ సాఫ్ట్వేర్ ఆర్కిటెక్ట్స్ మరియు క్లీన్ కోడ్ (Clean Code) పుస్తక రచయితలు సిఫార్సు చేసే అద్భుతమైన డిజైన్ ప్యాటర్న్: గార్డ్ క్లాజ్ (Guard Clause) లేదా ఎర్లీ రిటర్న్ (Early Return)!
కాన్సెప్ట్: ఏదైనా షరతు విఫలమైతే (Invalid Case), అక్కడికక్కడే వెంటనే ఎర్రర్ ఇచ్చి ఫంక్షన్ నుండి బయటకు (return) వచ్చేయాలి. అప్పుడు ప్రధాన బిజినెస్ లాజిక్ ఎటువంటి నెస్టెడ్ బ్రాకెట్లు లేకుండా ఫ్లాట్ గా, స్వచ్ఛంగా కనిపిస్తుంది.
// ✅ క్లీన్ కోడ్: గార్డ్ క్లాజెస్తో పిరమిడ్ ఆఫ్ డూమ్ను సమూలంగా నిర్మూలించాం!
void ProcessWithdrawalClean(decimal balance, decimal amount, bool isCardActive, bool isPinValid)
{
// గార్డ్ 1: కార్డు యాక్టివ్ కాకపోతే వెంటనే నిష్క్రమించు
if (!isCardActive)
{
Console.WriteLine("కార్డు బ్లాక్ చేయబడింది.");
return;
}
// గార్డ్ 2: పిన్ తప్పు అయితే వెంటనే నిష్క్రమించు
if (!isPinValid)
{
Console.WriteLine("తప్పుడు పిన్ నంబర్.");
return;
}
// గార్డ్ 3: మొత్తం సరైనది కాకపోతే నిష్క్రమించు
if (amount <= 0)
{
Console.WriteLine("చెల్లని మొత్తం.");
return;
}
// గార్డ్ 4: బ్యాలెన్స్ సరిపోకపోతే నిష్క్రమించు
if (balance < amount)
{
Console.WriteLine("ఖాతాలో సరిపడా నిధులు లేవు.");
return;
}
// అన్ని తనిఖీలు దాటిన తర్వాత మాత్రమే అసలైన గోల్డెన్ పాత్ ఎగ్జిక్యూట్ అవుతుంది!
Console.WriteLine($"విజయవంతం! విత్డ్రా చేసిన నగదు: ₹{amount:N2}");
}
// పరీక్షించడం:
ProcessWithdrawalClean(10000m, 2500m, true, true);
చూశారా? నెస్టెడ్ బ్రాకెట్లు పూర్తిగా మాయమైపోయాయి! కోడ్ ఒక కథలాగా పై నుండి క్రిందికి అత్యంత సులభంగా చదవగలిగేలా మారింది.
5 🔍 మోడ్రన్ C# Pattern Matching పరిచయం: is ఆపరేటర్తో Type Patterns
C# 7 నుండి ప్రారంభమై C# 12 వరకు విప్లవాత్మకంగా ఎదిగిన అతిపెద్ద ఫీచర్ Pattern Matching. సాంప్రదాయకంగా ఒక వేరియబుల్ ఏ రకానికి చెందినదో తెలుసుకోవడానికి మనం as ఆపరేటర్ వాడి, ఆ తర్వాత నల్ చెక్ చేయాల్సి వచ్చేది.
కానీ మోడ్రన్ C# లో Type Pattern ద్వారా టైప్ చెక్ చేయడం మరియు కొత్త వేరియబుల్లోకి క్యాస్ట్ చేయడం రెండూ ఒకే సమయంలో జరిగిపోతాయి:
object vehicleData = 180.50; // ఫ్లోటింగ్ పాయింట్ స్పీడ్ అనుకుందాం
// Type Pattern Matching: చెక్ చేయడం + వేరియబుల్ డిక్లేర్ చేయడం రెండూ ఒకేచోట!
if (vehicleData is double speed)
{
Console.WriteLine($"వాహనం వేగం (డబుల్): {speed:F1} km/h");
}
else if (vehicleData is string text)
{
Console.WriteLine($"టెక్స్ట్ సందేశం: {text.ToUpper()}");
}
else if (vehicleData is null)
{
Console.WriteLine("డేటా ఖాళీగా ఉంది (Null)!");
}
6 🎯 రిలేషనల్ ప్యాటర్న్స్ (Relational Patterns: >, <=)
C# 9 లో పరిచయం చేయబడిన అత్యంత అందమైన ఫీచర్ Relational Patterns. ఒక సంఖ్యను శ్రేణులలో (Ranges) తనిఖీ చేసేటప్పుడు వేరియబుల్ పేరును పదే పదే రాయవలసిన అవసరం లేకుండా డైరెక్ట్గా పోల్చవచ్చు!
int temperature = 38;
// సాంప్రదాయ పద్ధతి:
// if (temperature >= 35 && temperature <= 45)
// మోడ్రన్ C# 9+ Relational Pattern:
if (temperature is >= 35 and <= 45)
{
Console.WriteLine("వాతావరణం చాలా వేడిగా ఉంది (ఎండ తీవ్రత హెచ్చరిక)!");
}
else if (temperature is < 15)
{
Console.WriteLine("చలి వాతావరణం!");
}
else
{
Console.WriteLine("ఆహ్లాదకరమైన ఉష్ణోగ్రత.");
}
7 🔗 కంజంక్టివ్ & డిస్జంక్టివ్ ప్యాటర్న్స్ (and, or, not కీవర్డ్స్)
ఆధునిక C# లో ప్యాటర్న్ మ్యాచింగ్ రాసేటప్పుడు సింబల్స్ (&&, ||, !) కు బదులుగా సహజ ఆంగ్ల పదాలు and, or, not లను వాడవచ్చు.
char letter = 'k';
// అక్షరం ఓవెల్ (అచ్చు) కాదా అని సరిచూడటం
if (letter is 'a' or 'e' or 'i' or 'o' or 'u')
{
Console.WriteLine($"{letter} ఒక అచ్చు (Vowel)");
}
else if (letter is not (' ' or '\t' or '\n'))
{
Console.WriteLine($"{letter} ఒక హల్లు (Consonant)");
}
// నల్ చెకింగ్ లో విప్లవం:
string? response = "SUCCESS";
if (response is not null)
{
Console.WriteLine($"సందేశం: {response}");
}
if (x is not null) అనేది పాత if (x != null) కంటే ఎందుకు సురక్షితమైనదంటే — ఒక క్లాస్ లో != ఆపరేటర్ను ఎవరైనా తప్పుగా ఓవర్లోడ్ చేసినా సరే, is not null ఎల్లప్పుడూ నిజమైన మెమరీ పాయింటర్ను మాత్రమే చూస్తుంది!
8 📦 ప్రాపర్టీ ప్యాటర్న్స్ (Property Patterns)
ఒక క్లాస్ లేదా రికార్డ్ (Record) ఆబ్జెక్ట్ లోపల ఉన్న నిర్దిష్ట ప్రాపర్టీలను డైరెక్ట్గా తనిఖీ చేయడానికి Property Patterns ఉపయోగిస్తారు. ఇది ఆబ్జెక్ట్ లోపలికి చొచ్చుకుపోయి (Deep Inspection) అత్యంత క్లీన్ గా వెరిఫై చేస్తుంది.
// ఆర్డర్ డేటా స్ట్రక్చర్
var order = new { Id = 101, Amount = 4500.00, Country = "IN", IsPrime = true };
// ప్రాపర్టీ ప్యాటర్న్: ఆబ్జెక్ట్ ప్రాపర్టీలను డైరెక్ట్గా మ్యాచ్ చేయడం
if (order is { Country: "IN", Amount: >= 2000, IsPrime: true })
{
Console.WriteLine("🎉 సూపర్ ప్రీమియం భారతీయ ఆర్డర్! ఉచిత వన్-డే డెలివరీ అర్హత ఉంది.");
}
else
{
Console.WriteLine("ప్రామాణిక డెలివరీ వర్తిస్తుంది.");
}
9 📊 తులనాత్మక పట్టిక: సాంప్రదాయ if-else vs మోడ్రన్ C# Pattern Matching
ఈ రెండు విధానాల మధ్య నిర్మాణపరమైన తేడాలు:
| ఫీచర్ / కొలమానం | సాంప్రదాయ if-else (C# 1 - 6) | మోడ్రన్ Pattern Matching (C# 9 - 12) |
|---|---|---|
| రేంజ్ చెకింగ్ | if (x >= 10 && x <= 50) |
if (x is >= 10 and <= 50) (ఎలిగెంట్) |
| టైప్ కాస్టింగ్ & బైండింగ్ | రెండు స్టెప్స్: if (o is MyClass) { var c = (MyClass)o; } |
ఒకే స్టెప్: if (o is MyClass c) |
| నల్ సేఫ్టీ | if (o != null) (ఆపరేటర్ ఓవర్లోడ్ ముప్పుంది) |
if (o is not null) (100% పాయింటర్ సేఫ్) |
| మల్టిపుల్ ఆల్టర్నేటివ్స్ | if (c == 'a' || c == 'b' || c == 'c') |
if (c is 'a' or 'b' or 'c') |
| కాంప్లెక్స్ ఆబ్జెక్ట్ ఇన్స్పెక్షన్ | చేదుగా ఉండే మల్టిపుల్ డాట్ చెక్స్ (order != null && order.Amount > 100) |
క్లీన్ ప్రాపర్టీ ప్యాటర్న్: if (order is { Amount: > 100 }) |
| కోడ్ రీడబిలిటీ | సింబల్స్ క్లట్టర్ ఎక్కువగా ఉంటుంది | ఆంగ్ల వ్యాకరణం వలే సరళంగా ఉంటుంది |
10 ⚡ బ్రాంచింగ్ పెర్ఫార్మెన్స్ & హాట్-పాత్ ఆప్టిమైజేషన్ (Hot-Path Optimization)
హై-పెర్ఫార్మెన్స్ అప్లికేషన్లలో (ఉదాహరణకు సెకనుకు 1 లక్ష రిక్వెస్ట్లు వచ్చే పేమెంట్ గేట్వేలు), బ్రాంచ్లు రాసే వరుస క్రమం మొత్తం సిస్టమ్ స్పీడ్ను నిర్ణయిస్తుంది.
హాట్-పాత్ నియమం (Hot-Path Rule):
ఒక if-else-if లాడర్ రాసేటప్పుడు, 90% మంది యూజర్లకు ఏ కండిషన్ నిజమవుతుందో దాన్ని మొట్టమొదట పెట్టాలి! అరుదుగా జరిగే ఎక్సెప్షనల్ కేసులను ఆఖరున ఉంచాలి. దీనివల్ల CPU మొదటి చెక్లోనే సక్సెస్ అయి వెంటనే ముందుకు సాగుతుంది, అనవసరమైన కంపారిజన్లు తప్పుతాయి.
// 95% ట్రాన్సాక్షన్స్ "SUCCESS" అవుతాయి అనుకుందాం
string txStatus = "SUCCESS";
// ✅ ఆప్టిమైజ్డ్ ఆర్డర్: అత్యధికంగా జరిగేది ముందే ఉంది
if (txStatus == "SUCCESS")
{
// హాట్ పాత్! 95% సందర్భాలలో ఒక్క కండిషన్ చెక్ తోనే సరిపోతుంది.
Console.WriteLine("లావాదేవీ పూర్తయింది.");
}
else if (txStatus == "PENDING")
{
Console.WriteLine("బ్యాంక్ కన్ఫర్మేషన్ కోసం వేచి చూస్తున్నాం.");
}
else
{
// కేవలం 1% మాత్రమే జరిగే వైఫల్యం ఆఖరున ఉంది
Console.WriteLine("లావాదేవీ విఫలమైంది.");
}
11 🚀 రియల్-వరల్డ్ ప్రాజెక్ట్: "Smart Banking Loan Underwriting Engine"
ఈ అధ్యాయంలో నేర్చుకున్న గార్డ్ క్లాజెస్లు, రిలేషనల్ ప్యాటర్న్స్, మరియు ప్రాపర్టీ ప్యాటర్న్స్ ఉపయోగించి ఒక పూర్తి స్థాయి స్మార్ట్ బ్యాంకింగ్ లోన్ ఎలిజిబిలిటీ & అండర్రైటింగ్ ఇంజిన్ ను తయారు చేద్దాం.
using System;
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("🏦 మన బ్యాంక్ - స్మార్ట్ లోన్ ఎలిజిబిలిటీ ఇంజిన్ v1.0");
Console.WriteLine("=================================================\n");
// దరఖాస్తుదారు సమాచారం (Applicant Profile)
string applicantName = "సురేష్ వర్మ";
int age = 29;
int cibilScore = 780;
decimal monthlyIncome = 85000m;
decimal existingMonthlyEmi = 15000m;
decimal requestedLoanAmount = 2500000m; // 25 లక్షల లోన్
bool hasValidKyc = true;
// 1. గార్డ్ క్లాజ్: ప్రాథమిక KYC ధృవీకరణ
if (!hasValidKyc)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("❌ దరఖాస్తు తిరస్కరించబడింది: KYC పత్రాలు పూర్తి కాలేదు.");
Console.ResetColor();
return;
}
// 2. గార్డ్ క్లాజ్: వయోపరిమితి (Relational Pattern)
if (age is not (>= 21 and <= 60))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"❌ దరఖాస్తు తిరస్కరించబడింది: వయస్సు ({age}) 21 నుండి 60 ఏళ్ల మధ్య ఉండాలి.");
Console.ResetColor();
return;
}
// 3. గార్డ్ క్లాజ్: సిబిల్ స్కోర్ ఫిల్టర్
if (cibilScore < 650)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"❌ దరఖాస్తు తిరస్కరించబడింది: CIBIL స్కోర్ ({cibilScore}) కనీసం 650 ఉండాలి.");
Console.ResetColor();
return;
}
// 4. రుణ చెల్లింపు నిష్పత్తి (Debt-To-Income Ratio DTI)
decimal availableIncome = monthlyIncome - existingMonthlyEmi;
decimal dtiRatio = (existingMonthlyEmi / monthlyIncome) * 100m;
if (dtiRatio > 50m)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"⚠️ అధిక అప్పుల భారం: మీ DTI నిష్పత్తి {dtiRatio:F1}% ఉంది. 50% కంటే తక్కువ ఉండాలి.");
Console.ResetColor();
return;
}
// 5. మోడ్రన్ Pattern Matching తో వడ్డీ రేటు నిర్ణయం
decimal interestRate;
string riskCategory;
if (cibilScore is >= 750 && monthlyIncome is >= 50000m)
{
riskCategory = "అత్యంత సురక్షితమైన ప్రొఫైల్ (Tier-1 Premium)";
interestRate = 8.45m; // తక్కువ వడ్డీ
}
else if (cibilScore is >= 700 and < 750)
{
riskCategory = "మంచి ప్రొఫైల్ (Tier-2 Standard)";
interestRate = 9.20m;
}
else
{
riskCategory = "మధ్యస్థ రిస్క్ ప్రొఫైల్ (Tier-3 Moderate)";
interestRate = 10.50m;
}
// 6. గరిష్ట అర్హత మొత్తం (Max Eligible Amount = 40 రెట్ల నికర ఆదాయం)
decimal maxEligibleLoan = availableIncome * 40m;
bool isFullyApproved = requestedLoanAmount <= maxEligibleLoan;
// 7. అధికారిక మంజూరు పత్రం (Approval Letter)
Console.WriteLine("=================================================");
Console.WriteLine(" లోన్ మంజూరు వివరాల సారాంశం ");
Console.WriteLine("=================================================");
Console.WriteLine($"దరఖాస్తుదారు పేరు : {applicantName}");
Console.WriteLine($"వయస్సు : {age} సంవత్సరాలు");
Console.WriteLine($"CIBIL స్కోర్ : {cibilScore} ({riskCategory})");
Console.WriteLine($"నెలవారీ ఆదాయం : ₹{monthlyIncome:N2}");
Console.WriteLine($"ప్రస్తుత EMIలు : ₹{existingMonthlyEmi:N2} (DTI: {dtiRatio:F1}%)");
Console.WriteLine("-------------------------------------------------");
Console.WriteLine($"కోరిన లోన్ మొత్తం: ₹{requestedLoanAmount:N2}");
Console.WriteLine($"గరిష్ట అర్హత పరిమితి: ₹{maxEligibleLoan:N2}");
Console.WriteLine($"మంజూరైన వడ్డీ రేటు : {interestRate}% p.a.");
Console.WriteLine("-------------------------------------------------");
if (isFullyApproved)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("🎉 శుభవార్త! మీ లోన్ అభ్యర్థన సంపూర్ణంగా ఆమోదించబడింది!");
Console.ResetColor();
}
else
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"⚠️ పాక్షిక ఆమోదం: మీరు కోరిన మొత్తం కంటే గరిష్ట పరిమితి ₹{maxEligibleLoan:N2} కి మాత్రమే అర్హులు.");
Console.ResetColor();
}
Console.WriteLine("=================================================\n");
సిబిల్ స్కోర్, నెలవారీ జీతం, మరియు అప్పుల నిష్పత్తులను మార్చి లోన్ మంజూరు లాజిక్ మరియు రిస్క్ కేటగిరీ ఎలా స్వయంచాలకంగా మారుతుందో చూడండి!
12 🛑 బిగినర్స్ చేసే 7 ఘోరమైన బ్రాంచింగ్ తప్పులు
కండిషనల్ స్టేట్మెంట్స్ రాసేటప్పుడు అత్యధికంగా జరిగే 7 పొరపాట్లు:
if (score > 90); { doSomething(); } అని రాస్తే, సెమీకోలన్ వల్ల if స్టేట్మెంట్ అక్కడితో ముగిసిపోతుంది! కండిషన్ ఫాల్స్ అయినా సరే బ్రాకెట్ల లోపలి కోడ్ ఖచ్చితంగా రన్ అయిపోతుంది.
if (isActive == true) అని రాయడం అనవసరం. నేరుగా if (isActive) అని రాయడం క్లీన్ కోడ్ పద్ధతి.
5 లేదా 6 స్థాయిల నెస్టెడ్ if లతో కూడిన పిరమిడ్ ఆఫ్ డూమ్ కోడ్ రీడబిలిటీని నాశనం చేస్తుంది. ఎల్లప్పుడూ ఎర్లీ రిటర్న్ పద్ధతిని పాటించండి.
if (marks >= 35) ను మొదట పెట్టి, ఆ తర్వాత else if (marks >= 90) పెడితే, 95 మార్కులు వచ్చిన విద్యార్థి కూడా మొదటి కండిషన్లోనే ఆగిపోతాడు! ఎల్లప్పుడూ కఠినమైన షరతులను ముందే ఉంచాలి.
role == "admin" రాసినప్పుడు యూజర్ "Admin" అని ఇస్తే ఫాల్స్ అవుతుంది. string.Equals(role, "admin", StringComparison.OrdinalIgnoreCase) వాడాలి.
if (doubleVal == 1.0) ఎప్పుడూ నమ్మదగినది కాదు. బైనరీ ప్రెసిషన్ తేడాల వల్ల అది ఫెయిల్ కావచ్చు.
యూజర్ క్రియేట్ చేసిన క్లాస్ లో != ఆపరేటర్ ఓవర్లోడ్ అయి ఉంటే తప్పుడు ఫలితం రావచ్చు. is not null ఎల్లప్పుడూ పక్కాగా పనిచేస్తుంది.
13 🧠 ఇంటరాక్టివ్ సెల్ఫ్-అసెస్మెంట్ క్విజ్ (5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & వివరణలు)
కండిషనల్ లాజిక్ మరియు ప్యాటర్న్ మ్యాచింగ్పై మీ పట్టును ఈ క్రింది 5 క్విజ్ ప్రశ్నలతో పరిశీలించుకోండి:
❓ ప్రశ్న 1: if (x is not null) మరియు if (x != null) మధ్య తేడా ఏమిటి?
x != null అనేది ఆబ్జెక్ట్ లో రాసిన ఓవర్లోడెడ్ != ఆపరేటర్ను పిలవగలదు (దానిలో బగ్స్ ఉంటే తప్పుడు ఫలితం రావచ్చు). కానీ is not null అనేది ఆపరేటర్లను పట్టించుకోకుండా, స్వచ్ఛమైన రన్టైమ్ పాయింటర్ శూన్యమా కాదా అని గ్యారెంటీగా తనిఖీ చేస్తుంది.
❓ ప్రశ్న 2: సాఫ్ట్వేర్ ఆర్కిటెక్చర్లో "Guard Clauses" (ఎర్లీ రిటర్న్) వాడటం వల్ల కలిగే అతిపెద్ద ప్రయోజనం ఏమిటి?
❓ ప్రశ్న 3: if (age is >= 18 and <= 60) లో and కీవర్డ్ స్థానంలో && వాడవచ్చా?
is తర్వాత కేవలం ప్యాటర్న్ కాంబినేటర్లయిన and, or, not మాత్రమే అనుమతించబడతాయి. is >= 18 && <= 60 అని రాస్తే సింటాక్స్ ఎర్రర్ వస్తుంది.
❓ ప్రశ్న 4: Property Pattern if (user is { IsActive: true, Age: >= 21 }) ఒకవేళ user నల్ అయితే క్రాష్ అవుతుందా?
user నల్ అయితే, ఎటువంటి NullReferenceException లేకుండా నిశ్శబ్దంగా false రిటర్న్ చేస్తుంది.