Jak fungují řetězce v C#?

Question

Accepted Answer

V C# je **`string`** neměnný referenční typ představující text. Řetězce podporují interpolaci, bohatou knihovnu metod a — důležité pro výkon — `StringBuilder` pro efektivní opakovanou modifikaci.

## Interpolace řetězců a vytváření

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

**Interpolace řetězců** (`$"..."`) je moderní, čitelný způsob, jak vytvářet řetězce s vloženými hodnotami a specifikátory formátu. Doslova (`@`) řetězce znemožňují escape (ideální pro cesty/regex), a raw string literály (`"""`) zvládají víceřádkový text.

## Řetězce jsou neměnné

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

Každá operace, která "modifikuje" řetězec, ve skutečnosti vytváří **nový** řetězec (neměnnost). To je bezpečné, ale má náklady na výkon při opakované modifikaci.

## StringBuilder pro efektivní budování

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

Při budování řetězců ve smyčkách **`StringBuilder`** zabraňuje vytváření mnoha meziproduktů — klíčová praxe výkonu.

## Běžné metody řetězců

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

## Proč je to důležité

Manipulace se řetězci je rozšířená v programování (budování výstupu, zpracování vstupu, formátování dat), takže pochopení řetězců v C# je nezbytné každodenní znalosti.

Moderní funkce jsou důležité pro produktivitu: **interpolace řetězců** (`$"..."`) je čistý, čitelný způsob, jak vytvářet řetězce s vloženými hodnotami a formátováním, a doslova/raw string literály elegantně zvládají cesty a víceřádkový text.

Kriticky je pochopení, že **řetězce jsou neměnné** (každá "modifikace" vytváří nový řetězec), vysvětluje klíčovou otázku výkonu: naivní **zřetězování řetězců ve smyčkách** je plýtvavé (O(n²), vytváří mnoho meziproduktů), a vědění, kdy použít **`StringBuilder`** pro opakovanou modifikaci (která efektivně mutuje vnitřní vyrovnávací paměť), je důležitá praktická optimalizace, která přímo vyplývá z pochopení neměnnosti.

Pochopení bohaté knihovny metod řetězců (vyhledávání, nahrazování, dělení/spojování, formátování), moderní syntaxe interpolace a praxe StringBuilder řízené neměnností je základní znalostí pro neustálou práci s řetězci, kterou programování zahrnuje — plynulost zde, obzvláště pohodlí interpolace a oprava výkonu StringBuilder, je základní pro psaní čistého a efektivního C#.