Wie funktionieren Strings in C#?

Question

Accepted Answer

In C# ist **`string`** ein unveränderlicher Referenztyp, der Text darstellt. Strings unterstützen Interpolation, eine umfangreiche Methodenbibliothek und – wichtig für die Leistung – `StringBuilder` für effiziente wiederholte Modifikationen.

## String-Interpolation und -Erstellung

```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** (`$"..."`) ist der moderne, lesbare Weg, um Strings mit eingebetteten Werten und Formatierungsspezifizierern zu erstellen. Wörtliche (`@`) Strings deaktivieren das Escapen (ideal für Pfade/Regex), und Raw-String-Literale (`"""`) verarbeiten mehrzeiligen Text.

## Strings sind unveränderlich

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

Jede Operation, die einen String "modifiziert", erstellt tatsächlich einen **neuen** String (Unveränderlichkeit). Das ist sicher, hat aber Leistungskosten bei wiederholter Modifikation.

## StringBuilder für effizientes Erstellen

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

Beim Erstellen von Strings in Schleifen vermeidet **`StringBuilder`** die Erstellung vieler Zwischenstringsieci – eine Schlüssel-Leistungspraxis.

## Häufige 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);
```

## Warum es wichtig ist

String-Manipulation ist in der Programmierung allgegenwärtig (Ausgaben erstellen, Eingaben verarbeiten, Daten formatieren), daher ist das Verständnis von C#-Strings essentielles alltägliches Wissen.

Die modernen Funktionen sind wichtig für die Produktivität: **String-Interpolation** (`$"..."`) ist der saubere, lesbare Weg, um Strings mit eingebetteten Werten und Formatierung zu erstellen, und Wörtliche/Raw-String-Literale behandeln Pfade und mehrzeiligen Text elegant.

Kritisch ist das Verständnis, dass **Strings unveränderlich sind** (jede "Modifikation" erstellt einen neuen String) – das erklärt eine Schlüssel-Leistungsüberlegung: naives **String-Concatenation in Schleifen** ist verschwenderisch (O(n²), viele Zwischenstringse erstellen), und zu wissen, **`StringBuilder`** für wiederholte Modifikationen zu verwenden (das einen internen Buffer effizient mutiert), ist eine wichtige praktische Optimierung, die direkt aus dem Verständnis von Unveränderlichkeit folgt.

Die umfangreiche String-Methodenbibliothek zu kennen (Suche, Ersetzen, Aufteilen/Verbinden, Formatierung), die moderne Interpolationssyntax und die Unveränderlichkeits-getriebene StringBuilder-Praxis ist Kernwissen für die konstante String-Arbeit, die Programmierung beinhaltet – Geläufigkeit hier, besonders die Interpolationsbequemlichkeit und die StringBuilder-Leistungsoptimierung, ist grundlegend für das Schreiben von sauberem, effizientem C#.