C# இல் strings எவ்வாறு வேலை செய்கிறது?

Question

Accepted Answer

C# இல், **`string`** என்பது உரையைப் பிரதிநிதித்துவம் செய்யும் மாற்ற முடியாத reference type ஆகும். Strings interpolation, மிகச் செழுமையான method library, மற்றும் — செயல்திறனுக்கு முக்கியமாக — திறமையான மீண்டும் மாற்றுவதற்கான `StringBuilder` ஆகியவற்றை ஆதரிக்கிறது.

## String interpolation மற்றும் creation

```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** (`$"..."`) என்பது உட்பொதிக்கப்பட்ட மதிப்புகள் மற்றும் format specifiers கொண்டு strings கட்ட நவீன, படிக்கக்கூடிய வழியாகும். Verbatim (`@`) strings escaping ஐ முடக்குகிறது (paths/regex க்கு சிறந்தது), மற்றும் raw string literals (`"""`) பல-வரிசை உரையைக் கையாளுகிறது.

## Strings மாற்ற முடியாதவை

```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
```

ஒரு string ஐ "மாற்றும்" ஒவ்வொரு செயல்பாடும் உண்மையில் ஒரு **புதிய** string ஐ உருவாக்குகிறது (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();
```

Loops இல் strings கட்ட, **`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);
```

## ஏன் இது முக்கியமானது

String manipulation என்பது programming இல் எங்கும் உள்ளது (output கட்டுவது, input செயலாக்குவது, data format செய்வது), எனவே C# strings ஐ புரிந்துகொள்வது அவசியமான அன்றாட அறிவாகும்.

நவீன features உৎপাদনத்திற்கு முக்கியமாகும்: **string interpolation** (`$"..."`) உட்பொதிக்கப்பட்ட மதிப்புகள் மற்றும் formatting கொண்டு strings கட்ட சுத்தமான, படிக்கக்கூடிய வழியாகும், மற்றும் verbatim/raw string literals paths மற்றும் பல-வரிசை உரையை நேர்த்தியாக கையாளுகிறது.
/**முக்கியமாக, **strings மாற்ற முடியாதவை** (ஒவ்வொரு "மாற்றும்" புதிய string உருவாக்குகிறது) என்பதைப் புரிந்துகொள்வது ஒரு முக்கிய செயல்திறன் கருத்தாக்கத்தை விளக்குகிறது:天真な **string concatenation loops இல்** வீணாக உள்ளது (O(n²), பல intermediate strings உருவாக்குவது), மற்றும் மீண்டும் மாற்றுவதற்கு **`StringBuilder`** ஐப் பயன்படுத்த வேண்டும் என்பதை அறிந்திருப்பது (இது திறமையாக ஒரு internal buffer ஐ மாற்றுகிறது) immutability ஐ நরき்கொள்வதிலிருந்து நேரடியாக வரும் ஒரு முக்கிய நடைமுறை optimization ஆகும்.

ஸ்ட்রிங் method library (search, replace, split/join, formatting) பற்றி அறிந்திருப்பது, நவீன interpolation syntax, மற்றும் immutability-driven StringBuilder நடைமுறை programming அடிப்படை அறிவாகும் — fluency இங்கு, குறிப்பாக interpolation convenience மற்றும் StringBuilder செயல்திறன் தீர்வு, சுத்தமான, திறமையான C# எழுதுவதற்கு அடிப்படையாகும்.