C# లో స్ట్రింగ్‌లు ఎలా పని చేస్తాయి?

Question

Accepted Answer

C#లో, **`string`** అనేది టెక్స్ట్‌ను సూచించే immutable reference type. స్ట్రింగ్‌లు interpolation, సমృద్ధమైన method library, మరియు — పనితీరు కోసం ముఖ్యమైనది — పునరావృత సవరణ కోసం `StringBuilder`కు support చేస్తాయి.

## స్ట్రింగ్ interpolation మరియు సృష్టి

```csharp
string name = "Ann";
int age = 30;

// string interpolation ($) — embed expressions directly
string msg = $"Hello {name}, you are {age} years old";
string formatted = $"Price: {price:C2}";    // {value:format} — C2 = currency, 2 decimals

// verbatim strings (@) — no escaping, multi-line
string path = @"C:\Users\Ann";               // backslashes literal, no \ needed
string multi = """
    Raw string literal
    preserves formatting (C# 11)
    """;
```

**String interpolation** (`$"..."`) embedded values మరియు format specifiers లతో స్ట్రింగ్‌లను నిర్మించడానికి ఆధునిక, చదవదగిన మార్గం. Verbatim (`@`) స్ట్రింగ్‌లు escaping ను నిలిపివేస్తాయి (మార్గాలు/regex కోసం గ్రేట్), మరియు raw string literals (`"""`)
multi-line టెక్స్ట్‌ను నిర్వహిస్తాయి.

## స్ట్రింగ్‌లు immutable

```csharp
string s = "Hello";
s.ToUpper();        // returns a NEW string "HELLO"; s is unchanged
s = s + " World";    // creates a NEW string; the old "Hello" is discarded
```

స్ట్రింగ్‌ను "సవరించే" ప్రతి ఆపరేషన్ వాస్తవానికి **కొత్త** స్ట్రింగ్‌ను సృష్టిస్తుంది (immutability). ఇది సురక్షితమైనది కానీ పునరావృత సవరణ కోసం పనితీరు ఖర్చు ఉంది.

## సమర్థవంతమైన నిర్మాణ కోసం StringBuilder

```csharp
// ❌ string concatenation in a loop — creates a new string each iteration (slow, O(n²))
string result = "";
for (int i = 0; i < 10000; i++) result += i;

// ✅ StringBuilder mutates a buffer — efficient (O(n))
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string final = sb.ToString();
```

లూప్‌లలో స్ట్రింగ్‌లను నిర్మించడానికి, **`StringBuilder`** అనేక intermediate strings ను సృష్టించకుండా నివారిస్తుంది — ఒక కీ పనితీరు ఆచరణ.

## సాధారణ string methods

```csharp
s.Length; s.ToUpper(); s.Trim(); s.Substring(0, 5);
s.Contains("x"); s.IndexOf("x"); s.Replace("a", "b");
s.Split(','); string.Join(",", items);
string.IsNullOrEmpty(s); string.IsNullOrWhiteSpace(s);
```

## ఎందుకు ఇది ముఖ్యమైనది

ప్రోగ్రామింగ్‌లో స్ట్రింగ్ మానిప్యులేషన్ విస్తృతమైనది (output నిర్మాణం, input ప్రక్రియ, డేటా ఫార్మేటింగ్), కాబట్టి C# స్ట్రింగ్‌లను అర్థం చేసుకోవడం ఆవశ్యక రోజువారీ జ్ఞానం.

ఆధునిక features ఉత్పాదకత కోసం ముఖ్యమైనవి: **string interpolation** (`$"..."`)
embedded values మరియు formatting తో స్ట్రింగ్‌లను నిర్మించడానికి శుభ్ర, చదవదగిన మార్గం, మరియు verbatim/raw string literals మార్గాలు మరియు multi-line టెక్స్ట్‌ను సొగసుగా నిర్వహిస్తాయి.

విమర్శనాత్మకంగా, **strings immutable** అని అర్థం చేసుకోవడం (ప్రతి "సవరణ" కొత్త string ను సృష్టిస్తుంది) ఒక కీ పనితీరు పరిగణనను వివరిస్తుంది: naive **string concatenation loops లో** వ్యర్థమైనది (O(n²), అనేక intermediate strings నిర్మించడం), మరియు పునరావృత సవరణ కోసం **`StringBuilder`** ను ఉపయోగించాలని తెలుసుకోవడం (ఇది internal buffer ను సమర్థవంతంగా mutate చేస్తుంది) immutability నుండి నేరుగా వచ్చే ఒక ముఖ్యమైన ఆచరణ ఆప్టిమైజేషన్.

సమృద్ధమైన string method library (search, replace, split/join, formatting), ఆధునిక interpolation సింటాక్స్, మరియు immutability-driven StringBuilder ఆచరణ గురించి తెలుసుకోవడం ప్రోగ్రామింగ్ కలిగిన స్థిరమైన string పని కోసం కోర్ జ్ఞానం — ఇక్కడ ఫ్లూయెన్సీ, ముఖ్యంగా interpolation సౌలభ్యం మరియు StringBuilder పనితీరు సరిదిద్దడం, శుభ్ర, సమర్థవంతమైన C# రాయడానికి ప్రాథమికమైనది.