Jak działają stringi w C#?

Question

Accepted Answer

W C# **`string`** to niezmienny typ referencyjny reprezentujący tekst. Stringi obsługują interpolację, bogatą bibliotekę metod i — ważne dla wydajności — `StringBuilder` do efektywnej powtarzalnej modyfikacji.

## Interpolacja i tworzenie stringów

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

**Interpolacja stringów** (`$"..."`) to nowoczesny, czytelny sposób budowania stringów z osadzonymi wartościami i specyfikatorami formatu. Stringi prefiksem `@` (verbatim) wyłączają sekwencje ucieczki (doskonałe dla ścieżek/regex), a literały surowych stringów (`"""`) obsługują tekst wieloliniowy.

## Stringi są niezmienne

```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żda operacja, która "modyfikuje" string, faktycznie tworzy **nowy** string (niezmienność). To bezpieczne, ale ma koszt wydajności w przypadku powtarzalnych modyfikacji.

## StringBuilder do efektywnego budowania

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

Przy budowaniu stringów w pętlach **`StringBuilder`** pozwala uniknąć tworzenia wielu pośrednich stringów — kluczowa praktyka wydajności.

## Powszechne metody stringów

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

## Dlaczego to ważne

Manipulacja stringami jest wszechobecna w programowaniu (budowanie wyników, przetwarzanie danych wejściowych, formatowanie danych), dlatego zrozumienie stringów w C# jest niezbędną wiedzą na co dzień.

Nowocześnie funkcje mają znaczenie dla produktywności: **interpolacja stringów** (`$"..."`) to czysty, czytelny sposób budowania stringów z osadzonymi wartościami i formatowaniem, a stringi prefiksem `@` i literały surowe elegancko obsługują ścieżki i tekst wieloliniowy.

Krytycznie, zrozumienie, że **stringi są niezmienne** (każda "modyfikacja" tworzy nowy string) wyjaśnia kluczowe zagadnienie wydajności: naiwna **konkatenacja stringów w pętlach** jest zmarnowaniem (O(n²), tworzy wiele pośrednich stringów), a wiedza, że należy używać **`StringBuilder`** do powtarzalnych modyfikacji (który efektywnie mutuje wewnętrzny bufor), jest ważną praktyczną optymalizacją, która wynika bezpośrednio z zrozumienia niezmienności.

Znajomość bogatej biblioteki metod stringów (wyszukiwanie, zastępowanie, dzielenie/łączenie, formatowanie), nowoczesnej składni interpolacji i praktyki StringBuilder napędzanej niezmiennością to podstawowa wiedza do stałej pracy ze stringami, która towarzyszy programowaniu — biegłość tutaj, zwłaszcza wygoda interpolacji i optymalizacja wydajności StringBuilder, jest fundamentalna do pisania czystego, wydajnego C#.