C# ఆపరేటర్లు, ఎక్స్‌ప్రెషన్స్ & Null-Coalescing (??, ?.)

1 ➕ అరిథ్‌మెటిక్ ఆపరేటర్లు (Arithmetic Operators) & గణిత ఉచ్చులు

C# లో సంఖ్యా విలువలతో ప్రాథమిక గణితం చేయడానికి 5 ప్రధాన అరిథ్‌మెటిక్ ఆపరేటర్లు ఉన్నాయి:

• + (సంకలనం / Addition): రెండు సంఖ్యలను కూడుతుంది లేదా స్ట్రింగ్స్‌ను కలుపుతుంది.
• - (వ్యవకలనం / Subtraction): మొదటి సంఖ్య నుండి రెండవ సంఖ్యను తీసివేస్తుంది.
• * (గుణకారం / Multiplication): రెండు సంఖ్యలను గుణిస్తుంది.
• / (భాగహారం / Division): మొదటి సంఖ్యను రెండవ సంఖ్యతో భాగిస్తుంది.
• % (మాడ్యులస్ / Modulo Remainder): భాగహారం చేసిన తర్వాత మిగిలే శేషం (Remainder) ను ఇస్తుంది.

🚨 ది ఇంజర్ డివిజన్ ట్రాప్ (The 5 / 2 = 2 Trap):

చాలామంది బిగినర్స్ ఎదుర్కొనే అత్యంత సాధారణ బగ్: రెండు int వేరియబుల్స్‌ను భాగించినప్పుడు C# ఫలితాన్ని కూడా int గానే ఇస్తుంది! డెసిమల్ భాగం పూర్తిగా తుడిచిపెట్టుకుపోతుంది.

int totalScore = 15;
int subjects = 4;

// తప్పు దారి: int / int భాగహారం 3.75 కాకుండా 3 మాత్రమే ఇస్తుంది!
double wrongAvg = totalScore / subjects; 
Console.WriteLine($"తప్పుడు సగటు: {wrongAvg}"); // 3

// సరైన దారి: ఏదైనా ఒక సంఖ్యను double లేదా decimal కి క్యాస్ట్ చేయాలి
double correctAvg = (double)totalScore / subjects; 
Console.WriteLine($"ఖచ్చితమైన సగటు: {correctAvg}"); // 3.75

మాడ్యులస్ ఆపరేటర్ (%) యొక్క వాస్తవ అప్లికేషన్స్:

% కేవలం శేషాన్ని మాత్రమే ఇవ్వదు. ప్రోగ్రామింగ్‌లో ఇది:

1. సరి లేదా బేసి సంఖ్యలను కనుగొనడానికి (num % 2 == 0).
2. గడియారం సమయం (12-గంటల ఫార్మాట్ లూపింగ్: hours % 12).
3. టేబుల్ లో ఆల్టర్నేట్ రోస్ (Zebra Stripes) కి రంగులు వేయడానికి విరివిగా వాడతారు.

2 ⚡ ఇంక్రిమెంట్ & డిక్రిమెంట్ (Prefix vs Postfix: ++i vs i++)

ఒక వేరియబుల్ విలువను సరిగ్గా 1 పెంచడానికి ++, మరియు 1 తగ్గించడానికి -- వాడతారు. అయితే ఆపరేటర్ వేరియబుల్ కంటే ముందుందా (Prefix) లేదా వెనుక ఉందా (Postfix) అనే దానిపై కోడ్ ఫలితం పూర్తిగా ఆధారపడి ఉంటుంది.

int a = 10;
int b = ++a; // a అవుతుంది 11, b అవుతుంది 11
Console.WriteLine($"Prefix : a = {a}, b = {b}");

int p = 10;
int q = p++; // q అవుతుంది 10 (పాత విలువ), p అవుతుంది 11
Console.WriteLine($"Postfix: p = {p}, q = {q}");

// ఇంటర్వ్యూ క్లాసిక్ పజిల్:
int x = 5;
int result = x++ + ++x; 
// Step 1: x++ విలువ 5 (కానీ x అవుతుంది 6)
// Step 2: ++x ముందుగా 6 ని 7 చేస్తుంది, విలువ 7
// Result = 5 + 7 = 12, మరియు x ఆఖరి విలువ 7!
Console.WriteLine($"x = {x}, result = {result}");

3 ⚖️ రిలేషనల్ & సమానత్వ ఆపరేటర్లు (Relational & Equality)

రెండు విలువల మధ్య తారతమ్యాన్ని పోల్చడానికి రిలేషనల్ ఆపరేటర్లను ఉపయోగిస్తారు. వీటి ఫలితం ఎల్లప్పుడూ ఒక బూలియన్ (true లేదా false) మాత్రమే అవుతుంది:

• == (Equal to): రెండు విలువలు సమానమైతే true.
• != (Not Equal to): రెండు విలువలు సమానం కాకపోతే true.
• > (Greater than): ఎడమవైపు విలువ పెద్దదైతే true.
• < (Less than): ఎడమవైపు విలువ చిన్నదైతే true.
• >= (Greater than or Equal to): పెద్దది లేదా సమానమైతే true.
• <= (Less than or Equal to): చిన్నది లేదా సమానమైతే true.

4 🧠 లాజికల్ ఆపరేటర్లు & షార్ట్-సర్క్యూట్ మూల్యాంకనం (Short-Circuit Evaluation)

ఒకటి కంటే ఎక్కువ షరతులను కలిపి ఒక సంక్లిష్టమైన నిర్ణయం తీసుకోవడానికి లాజికల్ ఆపరేటర్లను ఉపయోగిస్తాం:

• && (Conditional Logical AND): రెండు షరతులూ true అయితేనే తుది ఫలితం true.
• || (Conditional Logical OR): ఏదైనా ఒక్క షరతు true అయినా తుది ఫలితం true.
• ! (Logical NOT): ఫలితాన్ని తిరగవేస్తుంది (true ని false గా, false ని true గా మారుస్తుంది).

షార్ట్-సర్క్యూట్ మూల్యాంకనం (Short-Circuit Evaluation) ఎలా ప్రాణాలు కాపాడుతుంది?

C# కంపైలర్ అనవసరమైన పనులు చేయదు.

• && విషయంలో మొదటి షరతు false అయితే, రెండవ షరతు ఎంత పెద్దదైనా సరే దాన్ని కనీసం తాకదు (ఎందుకంటే ఫలితం ఎలాగూ false కాబట్టి).
• || విషయంలో మొదటి షరతు true అయితే, రెండవ షరతును ఎగ్జిక్యూట్ చేయదు (ఎందుకంటే ఫలితం ఎలాగూ true కాబట్టి).

string? userEmail = null;

// షార్ట్-సర్క్యూట్ ఇక్కడ మన యాప్‌ను క్రాష్ అవ్వకుండా కాపాడుతుంది:
// userEmail != null అనేది false అయిన వెంటనే, కుడివైపున ఉన్న userEmail.Contains() ఎగ్జిక్యూట్ కాదు!
if (userEmail != null && userEmail.Contains("@"))
{
    Console.WriteLine("సరైన ఈమెయిల్!");
}
else
{
    Console.WriteLine("ఈమెయిల్ నమోదు కాలేదు లేదా చెల్లదు.");
}

5 ⚙️ బిట్‌వైజ్ & షిఫ్ట్ ఆపరేటర్లు (Bitwise & Shift Operators)

డేటాను బైట్ మరియు బిట్ స్థాయిలో ప్రాసెస్ చేయడానికి బిట్‌వైజ్ ఆపరేటర్లను ఉపయోగిస్తారు. గేమ్ డెవలప్‌మెంట్, నెట్‌వర్కింగ్ ప్రోటోకాల్స్, ఎన్‌క్రిప్షన్ మరియు యూజర్ పర్మిషన్స్ (Roles & Flags) నిర్వహణలో ఇవి అత్యంత వేగవంతమైన ప్రత్యామ్నాయాలు:

• & (Bitwise AND): రెండు బిట్లూ 1 అయితేనే 1.
• | (Bitwise OR): ఏదో ఒక బిట్ 1 అయినా 1.
• ^ (Bitwise XOR): రెండు బిట్లూ వేర్వేరుగా ఉంటేనే 1 (1^0=1, 1^1=0).
• ~ (Bitwise NOT): అన్ని బిట్లను తిరగవేస్తుంది (0 లు 1 గా, 1 లు 0 గా).
• << (Left Shift): బిట్లను ఎడమవైపుకు జరుపుతుంది (ప్రతి షిఫ్ట్‌కు విలువ 2 తో గుణించబడుతుంది).
• >> (Right Shift): బిట్లను కుడివైపుకు జరుపుతుంది (ప్రతి షిఫ్ట్‌కు విలువ 2 తో భాగించబడుతుంది).

// యూజర్ పర్మిషన్ బిట్స్: 1 = Read, 2 = Write, 4 = Delete
int READ_PERMISSION   = 1; // 0001
int WRITE_PERMISSION  = 2; // 0010
int DELETE_PERMISSION = 4; // 0100

// ఒక యూజర్‌కి Read & Write రెండూ ఇవ్వడం (Bitwise OR)
int userRights = READ_PERMISSION | WRITE_PERMISSION; // 0011 (విలువ: 3)

// యూజర్‌కి Delete పర్మిషన్ ఉందా? సరిచూడటం (Bitwise AND)
bool canDelete = (userRights & DELETE_PERMISSION) != 0;
bool canRead   = (userRights & READ_PERMISSION) != 0;

Console.WriteLine($"చదవగలరా? : {canRead}");     // True
Console.WriteLine($"తొలగించగలరా?: {canDelete}");  // False

// బిట్ షిఫ్టింగ్ మ్యాజిక్:
int num = 8;
Console.WriteLine($"8 << 1 (8 * 2) = {num << 1}"); // 16
Console.WriteLine($"8 >> 2 (8 / 4) = {num >> 2}"); // 2

6 🎯 టెర్నరీ ఆపరేటర్ (? :) — కాంపాక్ట్ కండిషనల్ ఎక్స్‌ప్రెషన్

నాలుగు లైన్ల if-else బ్లాక్ రాయడానికి బదులుగా, కేవలం ఒకే లైన్‌లో కండిషన్ ఆధారంగా విలువను కేటాయించడానికి Ternary Operator (condition ? trueValue : falseValue) ఒక అద్భుతమైన సాధనం.

int userAge = 20;

// సాంప్రదాయ పద్ధతి:
string accessStatus;
if (userAge >= 18) accessStatus = "అనుమతించబడింది";
else accessStatus = "తిరస్కరించబడింది";

// టెర్నరీ ఆపరేటర్ తో క్లీన్ & ఎలిగెంట్ కోడ్:
string modernStatus = (userAge >= 18) ? "అనుమతించబడింది" : "తిరస్కరించబడింది";
Console.WriteLine($"ఓటింగ్ స్టేటస్: {modernStatus}");

7 🛡️ ఆధునిక C# Null ఆపరేటర్లు: ?. , ?? , ??= మరియు !

సాఫ్ట్‌వేర్ పితామహుడు టోనీ హోర్ (Tony Hoare) నల్ పాయింటర్‌ను రూపొందించినందుకు దాన్ని "The Billion Dollar Mistake" అని పిలిచారు. C# లో రన్ అయ్యే యాప్స్ లో దాదాపు 70% క్రాషెస్ NullReferenceException వల్లే జరుగుతాయి. ఆధునిక C# (C# 6 నుండి C# 12 వరకు) ఈ సమస్యను సమూలంగా నిర్మూలించడానికి నాలుగు ప్రత్యేక ఆపరేటర్లను పరిచయం చేసింది:

1. Null-Conditional Operator (?.) — సేఫ్ నావిగేషన్

ఒక ఆబ్జెక్ట్ లేదా స్ట్రింగ్ నల్ కాకపోతేనే దాని ప్రాపర్టీని లేదా మెథడ్‌ను కాల్ చేస్తుంది. ఒకవేళ అది నల్ అయితే క్రాష్ అవ్వకుండా నిశ్శబ్దంగా null రిటర్న్ చేస్తుంది.

2. Null-Coalescing Operator (??) — డీఫాల్ట్ ఫాల్‌బ్యాక్

ఎడమవైపు ఉన్న విలువ నల్ అయితే, కుడివైపు ఉన్న డీఫాల్ట్ బ్యాకప్ విలువను కేటాయిస్తుంది. "ఇది లేకపోతే అది ఇవ్వు" అనే లాజిక్ ఇది.

3. Null-Coalescing Assignment Operator (??=)

ఒక వేరియబుల్ ఇప్పటికే నల్ అయి ఉంటే మాత్రమే దానికి కొత్త విలువను అసైన్ చేస్తుంది (C# 8+ ఫీచర్).

4. Null-Forgiving Operator (!)

కంపైలర్ ఇచ్చే నల్ వార్నింగ్ ను ఆపివేస్తూ, "ప్రోగ్రామర్‌గా నేను హామీ ఇస్తున్నాను, ఈ వేరియబుల్ ఎట్టిపరిస్థితుల్లోనూ నల్ కాదు" అని కంపైలర్‌కు చెప్పే ఆపరేటర్.

string? customerAddress = null;

// 1. Null-Conditional (?.) - క్రాష్ కాదు! safeLength లో null ఉంటుంది.
int? safeLength = customerAddress?.Length;
Console.WriteLine($"చిరునామా పొడవు: {safeLength ?? 0}");

// 2. Null-Coalescing (??) - శూన్యతకు విరుగుడు
string verifiedAddress = customerAddress ?? "చిరునామా అందుబాటులో లేదు";
Console.WriteLine($"వివరాలు: {verifiedAddress}");

// 3. Null-Coalescing Assignment (??=)
string? cachedToken = null;
cachedToken ??= "AUTH_TOKEN_DEFAULT_SECURE_999"; // నల్ కాబట్టి అసైన్ అవుతుంది
cachedToken ??= "ANOTHER_TOKEN"; // ఇప్పటికే విలువ ఉంది కాబట్టి మారదు!
Console.WriteLine($"Final Cached Token: {cachedToken}");

8 📐 ఆపరేటర్ ప్రిసిడెన్స్ & అసోసియేటివిటీ (Precedence & Associativity Table)

ఒకే గణిత సమీకరణంలో బహుళ ఆపరేటర్లు ఉన్నప్పుడు ఏది ముందు లెక్కించాలి అనే దానికి C# ఖచ్చితమైన ప్రాధాన్యతా నిబంధనలను (Operator Precedence) పాటిస్తుంది.

9 🔀 కాంపౌండ్ అసైన్‌మెంట్ ఆపరేటర్లు (Compound Assignment: +=, -=, *=)

ఒక వేరియబుల్‌పై ఆపరేషన్ చేసి ఫలితాన్ని మళ్లీ అదే వేరియబుల్‌కు కేటాయించే ప్రక్రియను కుదించి రాయడానికి కాంపౌండ్ అసైన్‌మెంట్ ఆపరేటర్లు తోడ్పడతాయి:

• x += 5; అంటే x = x + 5;
• x -= 3; అంటే x = x - 3;
• x *= 2; అంటే x = x * 2;
• x /= 4; అంటే x = x / 4;
• x %= 10; అంటే x = x % 10;

ఇవి రాయడానికి సంక్షిప్తంగా ఉండటమే కాకుండా, కొన్ని సందర్భాలలో కంపైలర్ ఇంటర్నల్ బైట్‌కోడ్ స్థాయిలో సింగిల్ రిజిస్టర్ ఆపరేషన్‌గా ఆప్టిమైజ్ చేస్తుంది.

10 🔍 టైప్ టెస్టింగ్ & కాస్టింగ్ ఆపరేటర్లు (is మరియు as)

ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో ఒక ఆబ్జెక్ట్ ఏ రకానికి చెందినదో తెలుసుకోవడానికి C# రెండు శక్తిమంతమైన ఆపరేటర్లను అందిస్తుంది:

• is ఆపరేటర్: ఒక ఆబ్జెక్ట్ నిర్దిష్ట టైప్‌కు అనుకూలమైనదా లేదా అని చెక్ చేసి true లేదా false ఇస్తుంది. ఆధునిక C# లో ఇది ప్యాటర్న్ మ్యాచింగ్‌తో కలిసి వేరియబుల్‌ను అక్కడికక్కడే అన్‌ప్యాక్ చేస్తుంది.
• as ఆపరేటర్: ఒక ఆబ్జెక్ట్‌ను నిర్దిష్ట క్లాస్‌గా కాస్ట్ చేయడానికి ప్రయత్నిస్తుంది. ఒకవేళ కాస్టింగ్ విఫలమైతే ఎక్సెప్షన్ ఇవ్వకుండా నిశ్శబ్దంగా null ఇస్తుంది (Safe Casting).

object mixedData = "హలో ప్రపంచం!";

// మోడ్రన్ C# Pattern Matching with 'is'
if (mixedData is string text)
{
    Console.WriteLine($"ఇది ఒక స్ట్రింగ్! పొడవు: {text.Length}");
}

// 'as' Operator తో సురక్షిత కాస్టింగ్
object numberBox = 12345;
string? strAttempt = numberBox as string; // నంబర్ ను స్ట్రింగ్ గా కాస్ట్ చేయలేము కాబట్టి null వస్తుంది

if (strAttempt == null)
{
    Console.WriteLine("కాస్టింగ్ సాధ్యం కాలేదు (Safe Null Result). యాప్ క్రాష్ కాలేదు!");
}

11 🚀 రియల్-వరల్డ్ ప్రాజెక్ట్: "Smart E-Commerce Cart & Coupon Engine"

ఈ అధ్యాయంలో నేర్చుకున్న అరిథ్‌మెటిక్, రిలేషనల్, లాజికల్ షార్ట్-సర్క్యూటింగ్, టెర్నరీ, మరియు ఆధునిక Null-Safety (?., ??, ??=) ఆపరేటర్లు అన్నింటినీ ఉపయోగించి ఒక పూర్తి స్థాయి స్మార్ట్ ఈ-కామర్స్ కార్ట్ & కూపన్ డిస్కౌంట్ ఇంజిన్ ను నిర్మిద్దాం!

using System;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("🛍️ మన షాపింగ్ కార్ట్ & స్మార్ట్ కూపన్ ఇంజిన్ v1.0");
Console.WriteLine("=================================================");

// 1. కస్టమర్ డేటా & Null-Coalescing
string? rawCustomerName = null; // యూజర్ పేరు ఇవ్వలేదు అనుకుందాం
string customerName = rawCustomerName ?? "అతిథి కస్టమర్ (Guest)";

// 2. కార్ట్ వస్తువులు & ధరలు
decimal item1Price = 1299.00m;
int item1Qty = 2;

decimal item2Price = 450.50m;
int item2Qty = 1;

decimal subTotal = (item1Price * item1Qty) + (item2Price * item2Qty);

// 3. కూపన్ కోడ్ ప్రాసెసింగ్ & లాజికల్ షార్ట్-సర్క్యూట్
string? couponCode = "MANA500";
decimal discountAmount = 0m;

// షార్ట్-సర్క్యూట్: couponCode నల్ కాకపోతేనే మరియు సమానమైతేనే డిస్కౌంట్ వర్తిస్తుంది
if (couponCode != null && couponCode.ToUpper() == "MANA500" && subTotal >= 2000m)
{
    discountAmount = 500m;
    Console.WriteLine("🎉 సూపర్ ఆఫర్! MANA500 కూపన్ ద్వారా ₹500 తగ్గింపు లభించింది!");
}
else
{
    Console.WriteLine("కూపన్ వర్తించలేదు లేదా కనీస కొనుగోలు ₹2000 కి చేరుకోలేదు.");
}

// 4. షిప్పింగ్ ఛార్జీలు (టెర్నరీ ఆపరేటర్)
// ₹1500 కంటే ఎక్కువ కొంటే ఉచిత డెలివరీ, లేకపోతే ₹100 ఛార్జ్
decimal netBeforeShipping = subTotal - discountAmount;
decimal shippingCharge = (netBeforeShipping >= 1500m) ? 0.00m : 100.00m;

// 5. డెలివరీ చిరునామా & Null-Coalescing Assignment (??=)
string? deliveryAddress = null;
deliveryAddress ??= "స్థానిక స్టోర్ పికప్ కౌంటర్ (Default Branch)";

// 6. తుది మొత్తం గణన
decimal grandTotal = netBeforeShipping + shippingCharge;

// 7. అందమైన ఆర్డర్ సారాంశం (Order Summary)
Console.WriteLine("\n=================================================");
Console.WriteLine("                 ఆర్డర్ సారాంశం (INVOICE)           ");
Console.WriteLine("=================================================");
Console.WriteLine($"కస్టమర్       : {customerName}");
Console.WriteLine($"డెలివరీ అడ్రస్: {deliveryAddress}");
Console.WriteLine("-------------------------------------------------");
Console.WriteLine($"మొత్తం వస్తువులు : {item1Qty + item2Qty}");
Console.WriteLine($"కార్ట్ సబ్-టోటల్  : ₹{subTotal:N2}");
Console.WriteLine($"కూపన్ తగ్గింపు : -₹{discountAmount:N2}");
Console.WriteLine($"షిప్పింగ్ ఛార్జ్: {(shippingCharge == 0m ? "ఉచితం (FREE)" : $"₹{shippingCharge:N2}")}");
Console.WriteLine("-------------------------------------------------");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"చెల్లించాల్సిన మొత్తం: ₹{grandTotal:N2}");
Console.ResetColor();
Console.WriteLine("=================================================");
Console.WriteLine("ఆర్డర్ విజయవంతంగా కన్ఫర్మ్ చేయబడింది! ధన్యవాదాలు! 🚀\n");

12 🛑 బిగినర్స్ చేసే 7 ఘోరమైన తప్పులు & ప్రొఫెషనల్ బెస్ట్ ప్రాక్టీసెస్

ఆపరేటర్లతో పనిచేసేటప్పుడు సాఫ్ట్‌వేర్ ఇంజనీర్లు తరచుగా చేసే 7 పొరపాట్లు మరియు వాటిని నివారించే నిబంధనలు:

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

ఆపరేటర్లపై మీ పట్టును నిరూపించుకోవడానికి ఈ 5 క్విజ్ ప్రశ్నలను పరిశీలించండి: