Comment fonctionnent les chaînes de caractères en C# ?

Question

Accepted Answer

En C#, **`string`** est un type référence immuable représentant du texte. Les chaînes supportent l'interpolation, une riche bibliothèque de méthodes, et — importantly pour les performances — `StringBuilder` pour une modification répétée efficace.

## Interpolation et création de chaînes

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

**L'interpolation de chaînes** (`$"..."`) est la façon moderne et lisible de construire des chaînes avec des valeurs imbriquées et des spécificateurs de format. Les chaînes littérales (`@`) désactivent l'échappement (excellent pour les chemins/regex), et les chaînes littérales brutes (`"""`) gèrent le texte multi-ligne.

## Les chaînes sont immuables

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

Chaque opération qui "modifie" une chaîne crée en fait une **nouvelle** chaîne (immuabilité). C'est sûr mais a un coût en performance pour les modifications répétées.

## StringBuilder pour une construction efficace

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

Pour construire des chaînes dans des boucles, **`StringBuilder`** évite de créer de nombreuses chaînes intermédiaires — une pratique de performance clé.

## Méthodes courantes de chaînes

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

## Pourquoi c'est important

La manipulation de chaînes est omniprésente en programmation (construire une sortie, traiter une entrée, formater des données), donc comprendre les chaînes C# est une connaissance essentielle au quotidien.

Les fonctionnalités modernes importent pour la productivité : **l'interpolation de chaînes** (`$"..."`) est la façon propre et lisible de construire des chaînes avec des valeurs imbriquées et du formatage, et les chaînes littérales verbatim/brutes gèrent les chemins et le texte multi-ligne élégamment.

De façon critique, comprendre que **les chaînes sont immuables** (chaque "modification" crée une nouvelle chaîne) explique une considération de performance clé : la **concaténation naïve de chaînes dans des boucles** est inefficace (O(n²), créant de nombreuses chaînes intermédiaires), et savoir utiliser **`StringBuilder`** pour une modification répétée (qui mute un buffer interne efficacement) est une optimisation pratique importante qui découle directement de la compréhension de l'immuabilité.

Connaître la riche bibliothèque de méthodes de chaînes (recherche, remplacement, split/join, formatage), la syntaxe d'interpolation moderne, et la pratique StringBuilder guidée par l'immuabilité est une connaissance fondamentale pour le travail constant sur les chaînes que la programmation implique — la fluidité ici, en particulier la commodité de l'interpolation et le correctif de performance StringBuilder, est fondamentale pour écrire du C# propre et efficace.