Aller au contenu principal

Chaînes de caractères

Notions théoriques​

Immutabilité des chaînes​

En C#, les chaînes (string) sont immuables : chaque opération de modification crée une nouvelle chaîne en mémoire.

string s = "Bonjour";
s = s.ToUpper();   // crée une nouvelle chaîne "BONJOUR", s pointe vers elle
// L'ancienne chaîne "Bonjour" est abandonnée

Méthodes courantes de string​

string texte = "  Bonjour le Monde  ";

// Nettoyage
Console.WriteLine(texte.Trim());          // "Bonjour le Monde"
Console.WriteLine(texte.TrimStart());     // "Bonjour le Monde  "
Console.WriteLine(texte.TrimEnd());       // "  Bonjour le Monde"

// Casse
Console.WriteLine(texte.ToUpper());       // "  BONJOUR LE MONDE  "
Console.WriteLine(texte.ToLower());       // "  bonjour le monde  "

// Longueur
Console.WriteLine(texte.Length);          // 20 (espaces inclus)

// Recherche
Console.WriteLine(texte.Contains("Monde"));     // true
Console.WriteLine(texte.StartsWith("  Bon"));   // true
Console.WriteLine(texte.EndsWith("de  "));      // true
Console.WriteLine(texte.IndexOf("le"));         // 9

// Extraction
Console.WriteLine(texte.Trim().Substring(0, 7)); // "Bonjour"

// Remplacement
Console.WriteLine(texte.Replace("Monde", "C#"));  // "  Bonjour le C#  "

// Découpage
string[] mots = "un,deux,trois".Split(',');   // ["un", "deux", "trois"]

Interpolation avec formatage​

double montant = 1234.567;
int nb = 42;

Console.WriteLine($"{montant:F2}");    // 1234,57
Console.WriteLine($"{montant:C}");     // 1 234,57 €
Console.WriteLine($"{nb:D5}");         // 00042
Console.WriteLine($"{0.175:P1}");      // 17,5 %

// Alignement
Console.WriteLine($"{"Nom",-20} {"Note",6}");    // colonne gauche 20, droite 6
Console.WriteLine($"{"Alice",-20} {15.5,6:F1}");

StringBuilder — efficacité pour les concatenations en boucle​

En C#, concatener des chaînes dans une boucle avec + est inefficace (crée une nouvelle chaîne à chaque itération). StringBuilder résout ce problème :

using System.Text;

var sb = new StringBuilder();
sb.Append("Bonjour");
sb.Append(", ");
sb.AppendLine("Alice !");     // Append + retour à la ligne
sb.Insert(0, ">>> ");         // insérer au début
sb.Replace("Alice", "Bob");

string resultat = sb.ToString();
Console.WriteLine(resultat);

Comparaison de chaînes​

string a = "Bonjour";
string b = "bonjour";

// Sensible à la casse
Console.WriteLine(a == b);                                        // false
Console.WriteLine(a.Equals(b));                                   // false

// Insensible à la casse
Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));  // true
Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // true

Chaînes verbatim et raw string literals​

// Chaîne verbatim : @ permet les backslashes sans échappement
string chemin = @"C:\Utilisateurs\Alice\Documents";

// Raw string literal (C# 11) : pas d'échappement du tout
string json = """
    {
        "nom": "Alice",
        "age": 20
    }
    """;

Exemple pratique​

// Analyse d'un texte
string texte = "Le langage C# est puissant, flexible et moderne. C# est utilisé partout.";

// Découpage en mots
string[] mots = texte.Split(new char[] { ' ', ',', '.', '!' }, StringSplitOptions.RemoveEmptyEntries);

// Statistiques
Console.WriteLine($"Texte analysé : \"{texte}\"");
Console.WriteLine($"Nombre de caractères : {texte.Length}");
Console.WriteLine($"Nombre de mots       : {mots.Length}");

// Trouver le mot le plus long
string plusLong = "";
foreach (string mot in mots)
    if (mot.Length > plusLong.Length)
        plusLong = mot;

Console.WriteLine($"Mot le plus long     : '{plusLong}' ({plusLong.Length} lettres)");

// Compter les occurrences de "C#"
int nbCS = 0;
foreach (string mot in mots)
    if (mot.Equals("C#", StringComparison.OrdinalIgnoreCase)) nbCS++;

Console.WriteLine($"Occurrences de C#    : {nbCS}");

// Trier les mots et afficher
Array.Sort(mots);
Console.WriteLine($"Mots triés : {string.Join(", ", mots.Distinct())}");

Test de mémorisation/compréhension​


Pourquoi les chaînes C# sont-elles dites 'immuables' ?


Quelle méthode retire les espaces en début et en fin d'une chaîne ?


Pourquoi utiliser `StringBuilder` plutôt que `+` dans une boucle ?


Comment comparer deux chaînes en ignorant la casse ?


Quelle syntaxe permet d'écrire un chemin Windows sans doubler les backslashes ?


TP pour réfléchir et résoudre des problèmes​

Vous allez analyser un texte et produire des statistiques.

Étape 1 — Découper le texte en mots​

Utilisez Split pour découper un texte en mots.


Bonne pratique - RemoveEmptyEntries pour éviter les mots vides

Sans StringSplitOptions.RemoveEmptyEntries, deux séparateurs consécutifs (double espace, ponctuation collée) génèrent des chaînes vides dans le résultat. L'option RemoveEmptyEntries les supprime automatiquement.

Étape 2 — Trouver le mot le plus long​

Parcourez le tableau et trouvez le mot le plus long.


Bonne pratique - Initialiser l'accumulateur de chaîne à ""

Initialiser plusLong = "" (chaîne vide, longueur 0) garantit que le premier mot sera toujours retenu comme candidat, car n'importe quel mot est plus long qu'une chaîne vide.

Étape 3 — Afficher les mots triés en majuscules​

Triez les mots et affichez-les en majuscules avec StringBuilder.


Bonne pratique - StringBuilder pour construire en boucle

Construire une longue chaîne en boucle avec + crée une nouvelle chaîne à chaque itération (coût O(n²)). StringBuilder maintient un tampon interne et ne copie qu'à la fin avec .ToString() (coût O(n)). Pour 5 mots c'est négligeable ; pour des milliers, la différence est énorme.

📌 Une solution