C# Academy · Leçon

Construire des chaînes

Concaténation et StringBuilder.

Construire des chaînes est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Assembler des chaînes avec +

La manière la plus simple de construire une chaîne consiste à assembler des fragments avec l'opérateur +.

On appelle cela la concaténation. Cette méthode convient bien à quelques fragments, par exemple pour combiner une formule de salutation avec un nom.

class Program
{
    static void Main()
    {
        string name = "Sam";
        string greeting = "Hi, " + name;
        System.Console.WriteLine(greeting);
    }
}

Interpolation de chaînes

L'interpolation est une manière plus claire d'insérer des valeurs dans un texte.

Placez un $ devant la chaîne et entourez les variables d'accolades. Les valeurs sont automatiquement insérées à l'endroit approprié.

class Program
{
    static void Main()
    {
        string name = "Sam";
        int age = 9;
        System.Console.WriteLine($"{name} is {age}");
    }
}

Le coût de += dans les boucles

Utiliser += pour agrandir une chaîne dans une boucle est lent.

Comme les chaînes sont immuables, chaque += crée une toute nouvelle chaîne et recopie tous les anciens caractères. Pour un grand nombre d'itérations, cela gaspille du temps et de la mémoire.

string result = "";
for (int i = 0; i < 1000; i++)
    result += i; // creates many strings

Découvrez StringBuilder

StringBuilder est conçu pour assembler efficacement du texte.

Il se trouve dans l'espace de noms System.Text. Au lieu de créer une nouvelle chaîne à chaque fois, il agrandit un tampon interne, ce qui est beaucoup plus rapide lorsqu'il faut effectuer de nombreux ajouts.

using System.Text;

StringBuilder sb = new StringBuilder();

Ajouter avec StringBuilder

Appelez Append pour ajouter du texte à un StringBuilder.

Vous pouvez ajouter de nombreux fragments les uns après les autres. Le générateur conserve tout dans son tampon jusqu'à ce que vous demandiez la chaîne finale.

using System.Text;
class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        sb.Append("Hello");
        sb.Append(", world");
        System.Console.WriteLine(sb.ToString());
    }
}

Obtenir la chaîne finale

Un StringBuilder n'est pas lui-même une string.

Lorsque vous avez terminé les ajouts, appelez ToString pour obtenir le texte final. Vous pouvez ensuite l'afficher ou le stocker comme n'importe quelle chaîne normale.

using System.Text;
StringBuilder sb = new StringBuilder();
sb.Append("Done");
string final = sb.ToString();

Ajouter dans une boucle

C'est dans ce cas que StringBuilder révèle tout son intérêt.

Ajoutez du texte dans une boucle : le générateur s'agrandit efficacement et évite les recopies que += créerait. Ce programme construit une chaîne de nombres.

using System.Text;
class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++)
            sb.Append(i);
        System.Console.WriteLine(sb.ToString());
    }
}

AppendLine

AppendLine fonctionne comme Append, mais ajoute également un saut de ligne après le texte.

C'est pratique pour construire une sortie sur plusieurs lignes, par exemple une liste où chaque élément se trouve sur sa propre ligne.

using System.Text;
class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine("Line 1");
        sb.AppendLine("Line 2");
        System.Console.Write(sb.ToString());
    }
}

Construire à partir de caractères

Vous pouvez également ajouter des valeurs char individuelles, et pas seulement des chaînes entières.

C'est utile lorsque vous transformez un texte caractère par caractère, par exemple en convertissant chaque lettre en majuscule lors de la construction d'un nouveau résultat.

using System.Text;
class Program
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();
        foreach (char c in "loud")
            sb.Append(char.ToUpper(c));
        System.Console.WriteLine(sb.ToString());
    }
}

Quand utiliser chaque méthode

Pour quelques fragments, + ou l'interpolation sont clairs et conviennent parfaitement.

Pour construire du texte dans une boucle ou assembler de nombreux fragments, préférez StringBuilder. En règle générale, utilisez les opérateurs pour un petit nombre d'assemblages et un générateur pour un grand nombre d'assemblages.

Assembler des chaînes

Lorsque vous disposez déjà d'une collection de fragments, string.Join les assemble en les séparant par un séparateur.

Vous fournissez d'abord le séparateur, puis les éléments. C'est une alternative concise à une boucle pour les listes simples.

string[] parts = { "a", "b", "c" };
string joined = string.Join("-", parts);
// joined is "a-b-c"

Vérification rapide

Évaluez votre compréhension de la construction de chaînes.

Récapitulatif

Utilisez + ou l'interpolation pour assembler quelques chaînes, et string.Join pour une liste de fragments.

Pour construire du texte dans des boucles, utilisez StringBuilder : appelez Append ou AppendLine, puis ToString pour obtenir le résultat. Cela évite les coûteuses recopies produites par +=, car les chaînes sont immuables.

Questions Fréquemment Posées

La leçon « Construire des chaînes » est-elle gratuite ?

Oui — le texte complet de « Construire des chaînes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire des chaînes » ?

Concaténation et StringBuilder. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Construire des chaînes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy