C# స్ట్రింగ్స్, ఇమ్యుటబిలిటీ & StringBuilder ఆప్టిమైజేషన్

⚡ Modern C# 12 / .NET 8 LTS 📖 Chapter 10 of 20 📁 Phase 03: మెథడ్స్, స్ట్రింగ్స్ & కలెక్షన్స్ 🎓 2026 Academic Edition
📌 Covered in this chapter: Text Processing in Computing · System.String & UTF-16 Unicode · Immutability Principle & Heap Re-allocations · String Interning (CLR String Pool) · Interpolation vs Composite Formatting · Verbatim (@) & C# 11+ Raw String Literals (""") · String Manipulation API (Substrings, Split, Join) · OrdinalIgnoreCase · StringBuilder Architecture & Buffer Growth · Performance Benchmark: string += vs StringBuilder · ReadOnlySpan<char> Zero-Allocation Slicing · Real-World Project: Banking Sensitive Data Redactor & Audit Engine · 7 Beginner Mistakes · Self-Assessment Quiz

స్వాగతం అధ్యాయం 10 కి! 📜 టెక్స్ట్ ప్రాసెసింగ్ & మెమరీ ఆప్టిమైజేషన్ రహస్యాలు

ప్రపంచవ్యాప్తంగా నడిచే వెబ్ సైట్లు, బ్యాంకింగ్ యాప్‌లు, మెసేజింగ్ ప్లాట్‌ఫారమ్‌లు మరియు కృత్రిమ మేధ (AI) మోడళ్లలో ఉపయోగించే సమాచారంలో 90% పైగా కేవలం టెక్స్ట్ రూపంలోనే (Strings) ఉంటుంది! కంప్యూటర్లు కేవలం 0 మరియు 1 లతో కూడిన గణితాన్ని మాత్రమే అర్థం చేసుకుంటాయి; అటువంటి బైనరీ సిస్టమ్‌పై మానవ భాష అక్షరాలను భద్రపరచడం ఒక అద్భుతం.

అయితే C# లో స్ట్రింగ్స్ అనేవి కేవలం సాధారణ అక్షరాల వరుస కాదు. C# ఆర్కిటెక్చర్‌లో స్ట్రింగ్స్ ఇమ్యుటబుల్ (Immutability - మార్చలేనివి)! అంటే ఒకసారి మెమరీలో స్ట్రింగ్ సృష్టించబడిన తర్వాత దాన్ని ఎప్పటికీ మార్చలేరు. మీరు str += "x" చేసిన ప్రతిసారీ పాత స్ట్రింగ్ మారదు; మెమరీ హీప్‌లో సరికొత్త స్ట్రింగ్ పుడుతుంది, మరియు పాత స్ట్రింగ్ గార్బేజ్ కలెక్టర్‌పై పెనుభారంగా మారుతుంది.

ఈ తీవ్రమైన మెమరీ సమస్యను అధిగమించడానికి C# మనకు StringBuilder మరియు ReadOnlySpan<char> వంటి అత్యున్నత హై-స్పీడ్ సాధనాలను అందించింది. ఈ సమగ్ర 10వ అధ్యాయంలో మనం స్ట్రింగ్ ఇంటర్నింగ్, మోడ్రన్ C# 11 Raw String Literals, స్ట్రింగ్ బిల్డర్ బఫర్ గ్రోత్ అల్గారిథమ్స్ నేర్చుకొని — బ్యాంకింగ్ రంగంలో వాడే సురక్షితమైన డేటా మాస్కింగ్ (PAN/Aadhaar Redaction) ఇంజిన్‌ను నిర్మిస్తాం!

1 📜 టెక్స్ట్ ప్రాసెసింగ్ & కంప్యూటింగ్ చరిత్ర

కంప్యూటర్ల ప్రారంభంలో కేవలం ఇంగ్లీష్ అక్షరాల కోసమే 7-బిట్ ASCII (0-127) ఉండేది. కానీ ప్రపంచంలోని తెలుగు, హిందీ, చైనీస్, జపనీస్ వంటి అన్ని భాషల లిపులను మరియు ఎమోజీలను (😀) ఒకే గొడుగు క్రిందకు తీసుకురావడానికి Unicode కన్సార్టియం ఏర్పడింది.

.NET లో System.String అనేది UTF-16 ఎన్‌కోడింగ్ ను ఉపయోగిస్తుంది. అంటే ప్రతి క్యారెక్టర్ (char) మెమరీలో సరిగ్గా 2 బైట్లను (16 బిట్లు) తీసుకుంటుంది. కాబట్టి 10 అక్షరాల స్ట్రింగ్ మెమరీలో కనీసం 20 బైట్లు (ప్లస్ ఆబ్జెక్ట్ హెడర్ ఓవర్‌హెడ్) ఆక్రమిస్తుంది.

2 🧱 C# String ఇంటర్నల్స్: System.String & చార్ అర్రే

C# లో చిన్న అక్షరాలతో రాసే string కీవర్డ్ మరియు పెద్ద అక్షరాలతో రాసే System.String క్లాస్ రెండూ 100% ఒక్కటే (Alias).

అంతర్గతంగా ఒక స్ట్రింగ్ అనేది సీక్వెన్షియల్ క్యారెక్టర్ అర్రే (Sequential char[]). కాబట్టి మీరు ఒక స్ట్రింగ్‌లోని అక్షరాలను అర్రే ఇండెక్స్ ద్వారా నేరుగా యాక్సెస్ చేయవచ్చు:

csharp · String Indexer Demonstration
string word = "DotNet";

Console.WriteLine($"మొదటి అక్షరం: {word[0]}"); // 'D'
Console.WriteLine($"ఆఖరి అక్షరం : {word[^1]}"); // 't' (C# 8 Index from end)
Console.WriteLine($"అక్షరాల పొడవు: {word.Length}"); // 6

3 🔒 ఇమ్యుటబిలిటీ (Immutability) సూత్రం & మెమరీ ట్రాప్

C# లో స్ట్రింగ్స్ యొక్క అత్యంత కీలకమైన లక్షణం: Immutability (మార్పులేని తత్వం)!

ఒకసారి మెమరీ హీప్‌లో "Hello" అనే ఆబ్జెక్ట్ ఏర్పడిన తర్వాత, దానిలోని ఏ ఒక్క అక్షరాన్ని కూడా మార్చలేరు. word[0] = 'B'; అని రాస్తే కంపైలర్ ఖరాఖండీగా ఎర్రర్ ఇస్తుంది!

🚨 లూప్ లోపల string += వాడితే ఏం జరుగుతుంది?

ఒకవేళ మీరు for (int i = 0; i < 10000; i++) str += i; అని రాస్తే, కంప్యూటర్ 10,000 సార్లు కొత్త కొత్త స్ట్రింగ్ ఆబ్జెక్టులను మెమరీలో సృష్టిస్తుంది! 9,999 పాత స్ట్రింగ్స్ చెత్తగా మారిపోతాయి. దీనివల్ల మెమరీ క్షణాల్లో నిండిపోయి, Garbage Collector (GC) తరచుగా రన్ అవుతూ సాఫ్ట్‌వేర్ ఫ్రీజ్ అయిపోతుంది.

4 🧠 స్ట్రింగ్ ఇంటర్నింగ్ (String Interning / CLR String Pool)

ఒక ప్రోగ్రామ్‌లో "Admin" అనే పదం 500 ఫైళ్లలో ఉండవచ్చు. వాటన్నింటికీ 500 వేర్వేరు మెమరీ కాపీలు సృష్టిస్తే రామ్ వృధా అవుతుంది.

దీనిని నివారించడానికి CLR ఒక ఇంటర్న్ పూల్ (String Intern Pool) అనే హాష్ టేబుల్‌ను నిర్వహిస్తుంది. కోడ్‌లో హార్డ్‌కోడ్ చేసిన స్ట్రింగ్ లిటరల్స్ అన్నీ ఒకేసారి పూల్ చేయబడి, అన్నింటికీ ఒకే మెమరీ అడ్రస్ రీ-యూజ్ అవుతుంది:

csharp · String Interning Proof
string s1 = "Hyderabad";
string s2 = "Hyderabad";

// ReferenceEquals: రెండూ మెమరీలో ఒకే చిరునామాను పంచుకుంటున్నాయా?
bool isSameMemory = object.ReferenceEquals(s1, s2);
Console.WriteLine($"ఒకే మెమరీ అడ్రస్ లో ఉన్నాయా? : {isSameMemory}"); // True! (Interning Magic)

5 ⚡ స్ట్రింగ్ ఫార్మాటింగ్, Verbatim (@) & C# 11 Raw String Literals

ఆధునిక C# లో టెక్స్ట్‌ను ఫార్మాట్ చేయడానికి 4 మార్గాలు ఉన్నాయి:

1. String Interpolation ($)

స్ట్రింగ్ లోపల నేరుగా వేరియబుల్స్‌ను $"{name} వయస్సు {age}" రూపంలో పొందుపరచడం అత్యంత ప్రజాదరణ పొందిన ఆధునిక మార్గం.

2. Verbatim Strings (@)

ఎస్కేప్ సీక్వెన్స్‌లు ( , , \) పట్టించుకోకుండా ఉన్నది ఉన్నట్లుగా చదవడానికి @ వాడతారు. ఫైల్ పాత్‌లు మరియు రెగ్యులర్ ఎక్స్‌ప్రెషన్స్‌కు ఇది సూపర్: @"C:UsersAdminDocuments".

3. C# 11+ Raw String Literals (""")

JSON, XML, SQL లేదా HTML వంటి సంక్లిష్టమైన కొటేషన్లతో కూడిన కోడ్‌ను రాసేటప్పుడు ఎటువంటి ఎస్కేప్ క్యారెక్టర్లు లేకుండా కనీసం మూడు డబుల్ కోట్స్ (""") తో రాయవచ్చు:

csharp · Modern C# 11 Raw String Literals
string customerName = "మనోజ్ కుమార్";
int accountId = 987654;

// C# 11 Raw String Literal ($$$""" ... """)
string jsonPayload = $$"""
{
    "user": {
        "name": "{{customerName}}",
        "account": {{accountId}},
        "status": "ACTIVE"
    }
}
""";

Console.WriteLine("స్పష్టమైన JSON పేలోడ్:");
Console.WriteLine(jsonPayload);

6 🧰 కీలక స్ట్రింగ్ మెథడ్స్ పవర్‌హౌస్ & OrdinalIgnoreCase

టెక్స్ట్ విశ్లేషణలో నిత్యం వాడే ముఖ్యమైన మెథడ్స్:

  • Trim() / TrimStart() / TrimEnd(): ముందు, వెనుక అనవసరమైన ఖాళీలను తొలగిస్తుంది.
  • Split(','): స్ట్రింగ్‌ను కామా లేదా డీలిమిటర్ వద్ద ముక్కలు చేసి string[] గా మారుస్తుంది.
  • string.Join(" - ", array): ఒక అర్రేలోని అంశాలన్నింటినీ కలిపి ఒకే స్ట్రింగ్‌గా మారుస్తుంది.
  • Contains(), StartsWith(), EndsWith(): పదాల ఉనికిని తనిఖీ చేస్తుంది.
  • Replace("old", "new"): పదాలను మారుస్తుంది.
csharp · Case-Insensitive String Comparison Best Practice
string inputRole = "admin";

// ❌ తప్పు దారి: ToUpper() లేదా ToLower() చేసి పోల్చడం వల్ల అనవసరంగా కొత్త స్ట్రింగ్ అలోకేట్ అవుతుంది
if (inputRole.ToUpper() == "ADMIN") { }

// ✅ ప్రొఫెషనల్ దారి: StringComparison.OrdinalIgnoreCase తో జీరో-అలోకేషన్ పోలిక
if (string.Equals(inputRole, "ADMIN", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("✅ అడ్మిన్ యాక్సెస్ నిర్ధారించబడింది!");
}

7 🚀 StringBuilder క్లాస్ — మ్యూటబుల్ టెక్స్ట్ బఫర్ ఆర్కిటెక్చర్

System.Text.StringBuilder అనేది ఇమ్యుటబుల్ స్ట్రింగ్‌కు విరుగుడు! ఇది ఒక మ్యూటబుల్ బఫర్ (Mutable Memory Buffer).

దీనిలో కొత్త టెక్స్ట్‌ను జతచేసినప్పుడు (Append), ప్రతిసారీ కొత్త ఆబ్జెక్ట్ పుట్టదు; అంతర్గతంగా ఉన్న చార్ అర్రే బఫర్‌లోనే టెక్స్ట్ పెరుగుతూ పోతుంది.

csharp · StringBuilder Methods in Action
using System.Text;

// ప్రారంభ కెపాసిటీ 128 అక్షరాలతో StringBuilder ను సృష్టించడం
StringBuilder sb = new StringBuilder(128);

sb.AppendLine("=== మన సాఫ్ట్‌వేర్ బిల్డ్ లాగ్ ===");
sb.Append("స్టేటస్: ").Append("SUCCESS").AppendLine();
sb.AppendFormat("తేదీ: {0:dd-MMM-yyyy}", DateTime.Now).AppendLine();
sb.Insert(0, "[CONFIDENTIAL] "); // ప్రారంభంలో చేర్చడం
sb.Replace("SUCCESS", "VERIFIED_OK"); // భర్తీ చేయడం

string finalLog = sb.ToString(); // చివరికి ఒకే ఒక్కసారి స్వచ్ఛమైన స్ట్రింగ్ గా మార్చడం
Console.WriteLine(finalLog);

8 📈 పెర్ఫార్మెన్స్ బెంచ్‌మార్క్: string += vs StringBuilder

1 లక్ష పదాలను కలపడానికి (Concatenation) ఈ రెండు విధానాలకు పట్టే సమయాన్ని విశ్లేషిస్తే:

csharp · Performance Showdown: += vs StringBuilder
using System.Diagnostics;
using System.Text;

int iterations = 20000;

// 1. StringBuilder టెస్ట్
Stopwatch sw = Stopwatch.StartNew();
StringBuilder builder = new StringBuilder();
for (int i = 0; i < iterations; i++)
{
    builder.Append(i);
}
string sbResult = builder.ToString();
sw.Stop();
Console.WriteLine($"StringBuilder సమయం: {sw.ElapsedMilliseconds} ms (క్షణాల్లో పూర్తి!)");

// 2. string += టెస్ట్ (చాలా నెమ్మదిగా నడుస్తుంది)
sw.Restart();
string slowStr = "";
for (int i = 0; i < iterations; i++)
{
    slowStr += i;
}
sw.Stop();
Console.WriteLine($"సాధారణ string += సమయం: {sw.ElapsedMilliseconds} ms (అపారమైన మెమరీ నష్టం!)");

9 📊 తులనాత్మక పట్టిక: string vs StringBuilder vs ReadOnlySpan<char>

టెక్స్ట్ ప్రాసెసింగ్ యొక్క 3 శక్తిమంతమైన సాధనాల తులనాత్మక పరిశీలన:

ఫీచర్ / కొలమానం System.String (string) System.Text.StringBuilder ReadOnlySpan<char>
మెమరీ స్వభావం Immutable (మార్చలేనిది) Mutable (మార్చదగిన బఫర్) Stack-only View (జీరో అలోకేషన్)
మెమరీ లొకేషన్ Managed Heap Managed Heap Stack / Direct Pointer
మార్పుల వేగం స్లో (ప్రతిసారీ రీ-అలోకేషన్) అత్యంత వేగం మెరుపు వేగం (Zero Copies)
థ్రెడ్ సేఫ్టీ ఇమ్యుటబుల్ కాబట్టి 100% Thread-safe Thread-safe కాదు Stack-bound కాబట్టి సహజసిద్ధ సేఫ్
ఉత్తమ వినియోగం తక్కువ మార్పులు గల సాధారణ టెక్స్ట్‌కు లూప్స్‌లో భారీ టెక్స్ట్ నిర్మాణం & లాగింగ్‌కు హై-పెర్ఫార్మెన్స్ పార్సర్లు & వెబ్ సర్వర్లకు

10 🎯 ఆధునిక ReadOnlySpan<char> తో జీరో-అలోకేషన్ స్లైసింగ్

సాధారణంగా text.Substring(0, 4) చేసినప్పుడు మెమరీలో కొత్త సబ్‌స్ట్రింగ్ పుడుతుంది. కానీ .NET లో AsSpan() వాడితే అసలైన మెమరీపై కేవలం ఒక కిటికీని (Window/View) మాత్రమే తెరుస్తుంది:

csharp · Zero-Allocation Substrings with ReadOnlySpan
string orderLog = "ORDER:2026-IN-98745:PAID";

// Substring వాడకుండా జీరో మెమరీ కాపీయింగ్ తో ఐడీ ని వేరు చేయడం:
ReadOnlySpan<char> span = orderLog.AsSpan();
ReadOnlySpan<char> orderId = span.Slice(6, 13); // "2026-IN-98745"

Console.WriteLine($"క్రాష్-రహిత జీరో-కాపీ ఐడీ: {orderId.ToString()}");

11 🚀 రియల్-వరల్డ్ ప్రాజెక్ట్: "Banking Sensitive Data Redactor & Audit Engine"

బ్యాంకింగ్ సిస్టమ్స్‌లో కస్టమర్ల ఆధార్ నంబర్, క్రెడిట్ కార్డు మరియు ఈమెయిల్ అడ్రస్‌లను లాగ్ ఫైల్స్ లోకి రాసేటప్పుడు సెక్యూరిటీ నిబంధనల ప్రకారం (RBI & PCI-DSS) మాస్కింగ్ (హైడింగ్) చేయాలి.

StringBuilder, Substring, మరియు మోడ్రన్ స్ట్రింగ్ API ఉపయోగించి — సున్నితమైన డేటాను మాస్క్ చేసే ఒక పూర్తి స్థాయి బ్యాంకింగ్ ఆడిట్ లాగ్ ఇంజిన్ ను తయారు చేద్దాం!

csharp · Banking Sensitive Data Redactor Project
using System;
using System.Text;

Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("=================================================");
Console.WriteLine("🔐 మన బ్యాంక్ - సెక్యూర్ డేటా మాస్కింగ్ & ఆడిట్ ఇంజిన్");
Console.WriteLine("=================================================\n");

// 1. ఆధార్ నంబర్ మాస్కింగ్ మెథడ్ (మొదటి 8 అంకెలు XXXXXXXX, ఆఖరి 4 అంకెలు కనిపిస్తాయి)
string MaskAadhaar(string aadhaar)
{
    string cleaned = aadhaar.Replace(" ", "").Replace("-", "");
    if (cleaned.Length != 12) return "XXXX-XXXX-XXXX";
    return $"XXXX-XXXX-{cleaned.Substring(8, 4)}";
}

// 2. క్రెడిట్ కార్డు మాస్కింగ్ (మొదటి 4, ఆఖరి 4 కనిపిస్తాయి, మధ్యలో **** ****)
string MaskCreditCard(string cardNo)
{
    string cleaned = cardNo.Replace(" ", "").Replace("-", "");
    if (cleaned.Length != 16) return "****-****-****-****";
    return $"{cleaned.Substring(0, 4)}-****-****-{cleaned.Substring(12, 4)}";
}

// 3. ఈమెయిల్ మాస్కింగ్ (మొదటి 2 అక్షరాలు + *** + @డొమైన్)
string MaskEmail(string email)
{
    int atIndex = email.IndexOf('@');
    if (atIndex <= 2) return "***@domain.com";
    string namePart = email.Substring(0, 2);
    string domainPart = email.Substring(atIndex);
    return $"{namePart}***{domainPart}";
}

// నమూనా కస్టమర్ సున్నిత సమాచారం
string customerName = "వెంకటేశ్వర రావు";
string rawAadhaar = "5432-8765-1098";
string rawCard = "4532 9876 5432 1099";
string rawEmail = "venkatesh.rao99@gmail.com";
decimal transferAmount = 75000.00m;

// 4. StringBuilder తో ఆడిట్ రసీదు నిర్మాణం
StringBuilder auditLog = new StringBuilder(512);

auditLog.AppendLine("=================================================");
auditLog.AppendLine("          అధికారిక సురక్షిత బ్యాంకింగ్ లాగ్       ");
auditLog.AppendLine("=================================================");
auditLog.AppendLine($"తేదీ & సమయం     : {DateTime.Now:dd-MMM-yyyy hh:mm:ss tt}");
auditLog.AppendLine($"ఖాతాదారు పేరు   : {customerName}");
auditLog.AppendLine($"ఆధార్ నంబర్    : {MaskAadhaar(rawAadhaar)}");
auditLog.AppendLine($"క్రెడిట్ కార్డు : {MaskCreditCard(rawCard)}");
auditLog.AppendLine($"రిజిస్టర్డ్ మెయిల్ : {MaskEmail(rawEmail)}");
auditLog.AppendLine("-------------------------------------------------");
auditLog.AppendLine($"బదిలీ చేసిన మొత్తం: ₹{transferAmount:N2}");
auditLog.AppendLine("భద్రతా స్థితి   : PCI-DSS 4.0 కంప్లైంట్ (Data Redacted)");
auditLog.AppendLine("=================================================");

Console.WriteLine(auditLog.ToString());
Console.WriteLine("✅ సున్నితమైన సమాచారం సురక్షితంగా మాస్క్ చేయబడింది! లాగ్ సేవ్ అయింది. 🚀\n");
🧪 లైవ్ కంపైలర్‌లో ఈ డేటా రెడాక్టర్ ఇంజిన్‌ను పరీక్షించండి!

మీ స్వంత ఆధార్ లేదా కార్డ్ నంబర్లు ఇచ్చి — సెన్సిటివ్ డిజిట్స్ స్వయంచాలకంగా ఎలా మాస్క్ చేయబడుతున్నాయో ఆన్‌లైన్ ఎడిటర్‌లో లైవ్‌గా పరిశీలించండి!

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

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

1. లూప్ లోపల string += వాడటం:

ఇది సిస్టమ్‌ను అత్యంత నెమ్మదిస్తుంది మరియు మెమరీని నింపుతుంది. లూప్‌లో ఎల్లప్పుడూ StringBuilder వాడాలి.

2. స్ట్రింగ్స్ పోల్చేటప్పుడు ToUpper() లేదా ToLower() వాడటం:

అనవసరమైన తాత్కాలిక స్ట్రింగ్స్ హీప్‌లో ఏర్పడతాయి. StringComparison.OrdinalIgnoreCase వాడటం ప్రొఫెషనల్ పద్ధతి.

3. str == "" లేదా str.Length == 0 తో ఖాళీతనాన్ని చెక్ చేయడం:

ఒకవేళ str నల్ అయితే NullReferenceException వస్తుంది! ఎల్లప్పుడూ string.IsNullOrEmpty(str) లేదా string.IsNullOrWhiteSpace(str) వాడాలి.

4. ఫైల్ పాత్స్‌లో సింగిల్ బ్యాక్‌స్లాష్ () వాడటం:

"C: ew est" లో మరియు ఎస్కేప్ అయి పాత్ పాడవుతుంది. వెర్బాటిమ్ @"C: ew est" వాడాలి.

5. స్ట్రింగ్ ఇండెక్స్‌ను బౌండరీ దాటించి పిలవడం:

ఖాళీ స్ట్రింగ్ పై str[0] పిలిస్తే IndexOutOfRangeException వస్తుంది. లెంగ్త్ చెక్ చేయకుండా ఇండెక్స్ వాడకండి.

6. StringBuilder కెపాసిటీని డిఫైన్ చేయకపోవడం:

డీఫాల్ట్ కెపాసిటీ కేవలం 16 అక్షరాలు. పెద్ద డేటా ఉన్నప్పుడు పదే పదే ఇంటర్నల్ అర్రే రీ-సైజ్ అవుతుంది. ప్రారంభంలోనే సైజు ఇవ్వడం మంచిది.

7. పాస్‌వర్డ్స్ వంటి సెన్సిటివ్ డేటాను సాధారణ string లో ఉంచడం:

స్ట్రింగ్స్ ఇమ్యుటబుల్ కాబట్టి మెమరీ డంప్‌లలో సులభంగా బయటపడతాయి. హై-సెక్యూరిటీ యాప్స్ లో SecureString లేదా char[] వాడాలి.

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

స్ట్రింగ్స్ మరియు మెమరీ ఆర్కిటెక్చర్‌పై మీ పట్టును ఈ 5 ప్రశ్నలతో పరీక్షించుకోండి:

❓ ప్రశ్న 1: C# లో "String Immutability" అంటే ఏమిటి మరియు దీనివల్ల కలిగే ప్రయోజనం ఏమిటి?
సమాధానం: ఒకసారి మెమరీలో స్ట్రింగ్ ఆబ్జెక్ట్ క్రియేట్ అయిన తర్వాత దానిలోని కంటెంట్‌ను మార్చలేము. దీనివల్ల స్ట్రింగ్స్ సహజసిద్ధంగా Thread-Safe అవుతాయి, మరియు బహుళ థ్రెడ్‌లు ఎటువంటి లాకింగ్ మెకానిజమ్స్ లేకుండా ఒకే స్ట్రింగ్‌ను సురక్షితంగా ఏకకాలంలో చదవగలవు.
❓ ప్రశ్న 2: string.IsNullOrEmpty(s) మరియు string.IsNullOrWhiteSpace(s) మధ్య తేడా ఏమిటి?
సమాధానం: IsNullOrEmpty అనేది స్ట్రింగ్ null లేదా పొడవు 0 ("") అయితేనే ట్రూ ఇస్తుంది. కానీ IsNullOrWhiteSpace స్ట్రింగ్‌లో కేవలం స్పేస్‌లు, ట్యాబ్‌లు లేదా న్యూలైన్‌లు (ఉదా: " ") ఉన్నా కూడా ట్రూ ఇస్తుంది. యూజర్ ఫారమ్ ఇన్‌పుట్ వాలిడేషన్‌కు IsNullOrWhiteSpace ఉత్తమం.
❓ ప్రశ్న 3: CLR "String Intern Pool" అంటే ఏమిటి?
సమాధానం: ఇది .NET రన్‌టైమ్ నిర్వహించే ఒక ఇంటర్నల్ టేబుల్. ప్రోగ్రామ్‌లోని ఒకేలాంటి స్ట్రింగ్ లిటరల్స్ అన్నింటికీ వేర్వేరు మెమరీ అలోకేట్ చేయకుండా, ఒకే కాపీని అన్ని వేరియబుల్స్ పంచుకునేలా చేసి ర్యామ్ (RAM) ను ఆదా చేస్తుంది.
❓ ప్రశ్న 4: C# 11 "Raw String Literals" యొక్క ప్రత్యేకత ఏమిటి?
సమాధానం: కనీసం మూడు డబుల్ కోట్స్ (""") తో ప్రారంభమై ముగిసే ఈ లిటరల్స్ లోపల JSON, XML లేదా SQL కోడ్‌లోని కొటేషన్లను ఎస్కేప్ (") చేయవలసిన అవసరం లేదు. అవి ఉన్నవి ఉన్నట్లుగా, మల్టీ-లైన్ ఇండెంటేషన్‌ను కాపాడుతూ స్పష్టంగా ఉంటాయి.
❓ ప్రశ్న 5: స్ట్రింగ్స్ పోల్చేటప్పుడు s1.ToUpper() == s2.ToUpper() ఎందుకు వాడకూడదు?
సమాధానం: ToUpper() ప్రతిసారీ మెమరీ హీప్‌లో సరికొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌ను అలోకేట్ చేస్తుంది, దీనివల్ల మెమరీ మరియు ప్రాసెసింగ్ వేస్ట్ అవుతుంది. దీనికి బదులుగా string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase) వాడితే ఎటువంటి మెమరీ అలోకేషన్ లేకుండా బైట్ స్థాయిలో వేగంగా పోలుస్తుంది.
← Previous: 09. మెథడ్స్ & పారామీటర్ మోడిఫైయర్స్ Next: 11. అర్రేలు (1D, 2D & Jagged Arrays) →
OC
Written by Our Compiler Technical Editorial Team
Reviewed for accuracy & tested on .NET 8 SDK / C# 12 runtime · 2026 Academic Edition