Conas a oibríonn teaghráin i C#?

Question

Accepted Answer

I C#, is cineál tagartha do-athraithe é **`string`** a ionann is téacs. Tacaíonn teaghráin le fionraí, leabharlann saibhir modhanna, agus — go tábhachtach do fheidhmíochta — `StringBuilder` le haghaidh athruithe éifeachtacha arís agus arís eile.

## Fionraí teaghráin agus cruthú

```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)
    """;
```

Is é **fionraí teaghráin** (`$"..."`) an bealach nua-aimseartha, sofhéachaint ar dhul i ngleic le teaghráin a bhfuil luachanna agus sonraitheoirí formáide leabaithe iontu. Cuireann teaghráin fabhracha (`@`) deireadh ar dhícheal (go hiontach do chosáin/regex), agus tugann teaghráin amh (`"""`) láimhseáil do théacs ilshiollach.

## Teaghráin do-athraithe

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

Gach oibríochta a "mhodhnóidh" teaghráin i ndáiríre cuireann sé teaghráin **nua** ar an saol (do-athraitheachta). Tá sé sábháilte ach tá costas feidhmíochta ann do athruithe arís agus arís eile.

## StringBuilder le haghaidh tógála éifeachtaí

```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();
```

Le haghaidh teaghráin a thógáil i duiliní, seachnaíonn **`StringBuilder`** go leor teaghráin idirmheánacha a chruthú — cleachtas feidhmíochta ríthábhachtach.

## Modhanna teaghráin choiteanna

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

## Cén fáth a bhíonn tábhacht leis

Tá ionchur teaghráin i bhformhór (tógáil aschuir, próiseáil ionchuir, sonraí a fhormáidiú), agus dá bhrí sin tá tuiscint ar theaghráin C# ríthábhachtach gach lá.

Tá ábhar ag na gnéithe nua-aimseartha do dhramhaeilíochta: is é **fionraí teaghráin** (`$"..."`) an bealach geal, sofhéachaint ar dhul i ngleic le teaghráin a bhfuil luachanna agus formáidithe leabaithe iontu, agus tugann teaghráin fabhracha/amh láimhseáil do chosáin agus do théacs ilshiollach go deas.

Go criticiúil, a thuigint go bhfuil **teaghráin do-athraithe** (cuireann gach "athrú" teaghráin nua ar an saol) a mhíníonn an meabhair feidhmíochta ríthábhachtach: bheith **nasc teaghráin i duiliní** a bheith spréachta (O(n²), go leor teaghráin idirmheánacha á chruthú), agus a bheith ar eolas go úsáid **`StringBuilder`** do athruithe arís agus arís eile (a athraíonn an buffer inmheánach go héifeachtúil) atá ina bharthanúchán cleachtais tábhachtach a thagann go díreach ó thuiscint ar do-athraitheachta.

A bheith ar eolas ar an leabharlann saibhir modhanna teaghráin (cuardach, athchur, roinnt/nasc, formáidiú), an comhréir idéartha nua-aimseartha, agus an spréachsa do-athraitheachta-dhíobhálach is eol gur eolaí lárnach atá ann don obair leantach teaghráin ar a bhíonn ar siúl i ríomhchlárúchán — bheith líofa anseo, go háirithe an tsóchéadúlacht idéarthúil agus an socrú feidhmíochta StringBuilder, tá sé bunúsach do dhul i ngleic le C# geal agus éifeachtach.