Hoe werken strings in C#?

Question

Accepted Answer

In C# is **`string`** een immutable reference type die tekst vertegenwoordigt. Strings ondersteunen interpolatie, een uitgebreide methodenbibliotheek, en — belangrijk voor prestaties — `StringBuilder` voor efficiënte herhaalde wijzigingen.

## String interpolatie en creatie

```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 interpolatie** (`$"..."`) is de moderne, leesbare manier om strings met ingebedde waarden en opmaakspecifiers te bouwen. Verbatim (`@`) strings schakelen escaping uit (geweldig voor paden/regex), en raw string literals (`"""`) verwerken meerregelige tekst.

## Strings zijn 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
```

Elke operatie die een string "wijzigt" maakt eigenlijk een **nieuwe** string (immutabiliteit). Dit is veilig maar heeft prestatieverliezen voor herhaalde wijzigingen.

## StringBuilder voor efficiënt bouwen

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

Bij het bouwen van strings in lussen vermijdt **`StringBuilder`** het maken van veel tussenliggende strings — een sleutelprestatiesvraag.

## Veelgebruikte string-methoden

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

## Waarom het belangrijk is

Stringmanipulatie komt overal in programmeren voor (uitvoer bouwen, invoer verwerken, gegevens opmaken), dus het begrijpen van C# strings is essentiële dagelijkse kennis.

Moderne functies zijn belangrijk voor productiviteit: **string interpolatie** (`$"..."`) is de schone, leesbare manier om strings met ingebedde waarden en opmaak te bouwen, en verbatim/raw string literals verwerken paden en meerregelige tekst elegant.

Kritiek is begrijpen dat **strings immutable zijn** (elke "wijziging" maakt een nieuwe string) en verklaart een belangrijke prestatieoverweging: naïeve **string concatenatie in lussen** is verspilling (O(n²), veel tussenliggende strings creëren), en weten dat je **`StringBuilder`** voor herhaalde wijzigingen moet gebruiken (wat efficiënt een interne buffer mutateert) is een belangrijk praktisch optimalisatie dat rechtstreeks uit het begrijpen van immutabiliteit volgt.

De uitgebreide string-methodenbibliotheek kennen (zoeken, vervangen, splitsen/samenvoegen, opmaak), de moderne interpolatiesyntaxis, en de immutabiliteit-gestuurd StringBuilder-praktijk vormen kernkennis voor het constante stringwerk dat programmeren met zich meebrengt — vaardigheid hier, vooral het interpolatiegemak en de StringBuilder-prestatiesfix, is fundamenteel voor het schrijven van schoon, efficiënt C#.