CodeGym /Cours /C# SELF /La classe StringBuilder pour bosser avec les chaînes

La classe StringBuilder pour bosser avec les chaînes

C# SELF
Niveau 9, Leçon 5
Disponible

1. Intro

Petit rappel, les chaînes en C# sont immuables (immutable). Ça veut dire qu'une fois créée, tu peux plus la modifier : toutes les opérations qui semblent "modifier" la chaîne créent en fait une nouvelle chaîne en mémoire.

Par exemple, quand tu écris :

string hello = "Salut";
hello += " monde !"; // On dirait que hello a changé, mais en vrai c'est un nouvel objet !

La variable hello pointe vers un nouvel objet, et l'ancien (s'il n'est plus utilisé) sera un jour viré par le garbage collector. Si tu fais ce genre de trucs plein de fois dans une boucle, tu risques de "saturer" la RAM et de voir les perfs s'effondrer. C'est flagrant si tu concatènes des milliers ou millions de chaînes : à chaque étape, une nouvelle chaîne est créée, tous ses caractères sont copiés, les vieux objets traînent jusqu'au garbage collector, et ton programme commence à ramer sévère.

Et c'est là que débarque le héros de cette conf — StringBuilder.


using System.Text; // ← obligatoire !
StringBuilder sb = new StringBuilder("Salut");
sb.Append(" monde !"); // Là, la chaîne change vite et efficacement

Découverte de StringBuilder

StringBuilder — c'est une classe du namespace System.Text. Son taf — construire et assembler efficacement de grosses chaînes, en modifiant leur contenu sans créer tout le temps de nouveaux objets.

Petite analogie :
Si une chaîne (string) c'est un morceau de mosaïque que tu peux juste remplacer en entier, alors StringBuilder c'est un tableau magnétique où tu peux coller et décoller les morceaux à l'infini, sans devoir changer de tableau à chaque fois que tu veux ajouter ou retirer un bout de mosaïque.

Quand utiliser StringBuilder ?

  • Si tu modifies une chaîne plein de fois (surtout dans une boucle).
  • Si tu construis du texte à partir de plein de petits bouts.
  • Si tu fais gaffe à la vitesse et à la mémoire.

Quand NE PAS l'utiliser ?

  • Si t'as juste 1 ou 2 opérations simples sur une chaîne — le string classique est plus simple et plus lisible.
  • Si tu veux vraiment (pour une raison chelou) garder chaque état de la chaîne.

2. Création et opérations de base avec StringBuilder

Importer le namespace

Pour commencer, c'est simple : n'oublie pas d'importer le namespace.

using System.Text;// ← obligatoire !

Façons de créer une nouvelle chaîne


StringBuilder sb1 = new StringBuilder();            // Vide
StringBuilder sb2 = new StringBuilder("Départ");    // Avec du texte de départ
StringBuilder sb3 = new StringBuilder(100);         // Avec une capacité pour 100 caractères

Méthodes principales

var sb = new StringBuilder("Début");
sb.Append(" + on a ajouté du nouveau texte"); 			// Ajouter à la fin
sb.AppendLine(" (et ça avec un retour à la ligne)"); 	// Ajouter avec \n
sb.Insert(0, "Départ : "); 						// Insérer à la position 0
sb.Remove(0, 8); 								// Supprimer 8 caractères à partir de la position 0
sb.Replace("texte", "STRING"); 					// Remplacer tous les "texte" par "STRING"
string result = sb.ToString(); 					// Récupérer la chaîne finale

3. Efficacité de StringBuilder

Exemple : comparaison de perfs

Imaginons qu'il faut assembler une chaîne avec 10 000 nombres à la suite (genre on t'a demandé d'afficher tous les numéros de tes potes de promo) :

Approche naïve (string)

string text = "";
for (int i = 0; i < 10000; i++)
{
    text += i + " "; // À chaque étape, une nouvelle chaîne est créée !
}
Console.WriteLine(text.Substring(0, 100) + "..."); // Pour raccourcir l'affichage

Approche optimale (StringBuilder)

var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
{
    sb.Append(i).Append(' '); // On peut enchaîner !
}
Console.WriteLine(sb.ToString().Substring(0, 100) + "...");

C'est quoi la diff ?
La première version va tourner beaucoup plus lentement et peut bouffer beaucoup plus de RAM. La seconde — rapide et économe en mémoire.

4. Les méthodes les plus populaires de StringBuilder

Append — ajoute une chaîne ou un autre type (converti automatiquement en chaîne) :

sb.Append("texte");
sb.Append(123); // 123 devient "123"
sb.Append('!'); // Un caractère

AppendLine — ajoute une chaîne + un retour à la ligne :

sb.AppendLine("ligne"); // Ajoute "ligne\n"

Insert — insère une chaîne à une position précise :

sb.Insert(0, "Hello, "); // Insertion au début

Remove — supprime plusieurs caractères :

sb.Remove(3, 4); // Supprime 4 caractères à partir de la position 3

Replace — remplace toutes les occurrences d'une sous-chaîne ou d'un caractère :

sb.Replace("old", "new");
sb.Replace('a', 'A');

ToString — renvoie la chaîne finale.

Couper une chaîne

Contrairement à string, tu peux donner une nouvelle longueur à un objet StringBuilder. La chaîne sera coupée à cette longueur.

sb.Length = 10; // Tout ce qui est après le 10e caractère — disparaît !

5. Particularités et pièges classiques

Pourquoi ToString() est important

Tant que tu bosses avec StringBuilder, t'as pas une chaîne dans les mains, mais un objet spécial. Beaucoup de méthodes (genre Console.WriteLine) l'acceptent sans souci, parce qu'il sait se convertir en chaîne tout seul, mais parfois tu peux avoir une surprise — si tu compares par erreur avec une chaîne classique ou si tu fais un truc du genre :

if (sb == "Salut") { ... } // Oups ! Ça marchera pas, même si sb contient "Salut"

Le résultat sera false : tu compares pas des chaînes, mais des objets de types différents.

La bonne façon :

if (sb.ToString() == "Salut") { ... }

Mutabilité

Contrairement à string, StringBuilder est mutable ! Un seul objet peut changer de contenu autant de fois que tu veux, c'est ça qui booste la vitesse.

N'oublie pas le ToString() à la fin, sinon tu récupères pas une chaîne mais un truc chelou genre System.Text.StringBuilder.

Taille du buffer et réallocation

À l'intérieur, StringBuilder garde un tableau de caractères. Si tu sais d'avance que tu vas "bidouiller" une très longue chaîne, tu peux passer la longueur prévue au constructeur — ça accélère un peu le taf.

var bigBuilder = new StringBuilder(50000); // On prévoit 50 000 caractères

Mais si tu t'es planté — pas grave ! StringBuilder agrandira le buffer tout seul si besoin, ce sera juste un peu plus lent.

Dépassement de mémoire ?

En théorie, si tu fais vraiment n'importe quoi et ajoutes des milliards de caractères, tu peux finir par avoir un OutOfMemoryException, mais pour les vrais projets ça arrive quasi jamais.

2
Mission
C# SELF, niveau 9, leçon 5
Bloqué
Modification d'une chaîne avec les méthodes de `StringBuilder`
Modification d'une chaîne avec les méthodes de `StringBuilder`
2
Mission
C# SELF, niveau 9, leçon 5
Bloqué
Création d'une liste de nombres avec `StringBuilder`
Création d'une liste de nombres avec `StringBuilder`
1
Étude/Quiz
Travail avec les chaînes, niveau 9, leçon 5
Indisponible
Travail avec les chaînes
Travail avancé avec les chaînes
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION