Comment : modifier du contenu de chaîne (Guide de programmation C#)

Mise à jour : Juillet 2008

Parce que les chaînes sont immuables, il n'est pas possible (sans utiliser du code non sécurisé) de modifier la valeur d'un objet chaîne après qu'il a été créé. Toutefois, il y a de nombreuses façons de modifier la valeur d'une chaîne et de stocker le résultat dans un nouvel objet chaîne. La classe System.String fournit des méthodes qui utilisent une chaîne d'entrée et retournent un nouvel objet chaîne. Dans de nombreux cas, vous pouvez assigner le nouvel objet à la variable qui contenait la chaîne d'origine. La classe System.Text.RegularExpressions.Regex fournit des méthodes supplémentaires qui fonctionnent de façon semblable. La classe System.Text.StringBuilder fournit une mémoire tampon de caractères que vous pouvez modifier « sur place ». Vous appelez la méthode StringBuilder.ToString pour créer un objet chaîne qui contient le contenu actuel de la mémoire tampon.

Exemple

L'exemple suivant indique différentes façons de remplacer ou de supprimer des sous-chaînes dans une chaîne spécifiée.

class ReplaceSubstrings
{
    string searchFor;
    string replaceWith;

    static void Main(string[] args)
    {

        ReplaceSubstrings app = new ReplaceSubstrings();
        string s = "The mountains are behind the clouds today.";

        // Replace one substring with another with String.Replace.
        // Only exact matches are supported.
        s = s.Replace("mountains", "peaks");
        Console.WriteLine(s);
        // Output: The peaks are behind the clouds today.

        // Use Regex.Replace for more flexibility. 
        // Replace "the" or "The" with "many" or "Many".
        // using System.Text.RegularExpressions
        app.searchFor = "the"; // A very simple regular expression.
        app.replaceWith = "many";
        s = Regex.Replace(s, app.searchFor, app.ReplaceMatchCase, RegexOptions.IgnoreCase);
        Console.WriteLine(s);
        // Output: Many peaks are behind many clouds today.

        // Replace all occurrences of one char with another.
        s = s.Replace(' ', '_');
        Console.WriteLine(s);
        // Output: Many_peaks_are_behind_many_clouds_today.

        // Remove a substring from the middle of the string.
        string temp = "many_";
        int i = s.IndexOf(temp);
        if (i >= 0)
        {
            s = s.Remove(i, temp.Length);
        }
        Console.WriteLine(s);
        // Output: Many_peaks_are_behind_clouds_today.

        // Remove trailing and leading whitespace.
        // See also the TrimStart and TrimEnd methods.
        string s2 = "    I'm wider than I need to be.      ";
        // Store the results in a new string variable.
        temp = s2.Trim();
        Console.WriteLine(temp);
        // Output: I'm wider than I need to be.

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }

    // Custom match method called by Regex.Replace
    // using System.Text.RegularExpressions
    string ReplaceMatchCase(Match m)
    {
        // Test whether the match is capitalized
        if (Char.IsUpper(m.Value[0]) == true)
        {
            // Capitalize the replacement string
            // using System.Text;
            StringBuilder sb = new StringBuilder(replaceWith);
            sb[0] = (Char.ToUpper(sb[0]));
            return sb.ToString();
        }
        else
        {
            return replaceWith;
        }
    }
}

Pour accéder aux différents caractères d'une chaîne en utilisant la notation de tableau, vous pouvez utiliser l'objet StringBuilder, qui surcharge l'opérateur [] pour permettre l'accès à la mémoire tampon de caractères interne. Vous pouvez également convertir la chaîne en un tableau de caractères en utilisant la méthode ToCharArray. L'exemple suivant utilise ToCharArray pour créer le tableau. Certains éléments de ce tableau sont ensuite modifiés. Un constructeur String prenant les tableaux de caractères comme paramètres d'entrée est alors appelé pour créer une chaîne.

class ModifyStrings
{
    static void Main()
    {
        string str = "The quick brown fox jumped over the fence";
        System.Console.WriteLine(str);

        char[] chars = str.ToCharArray();
        int animalIndex = str.IndexOf("fox");
        if (animalIndex != -1)
        {
            chars[animalIndex++] = 'c';
            chars[animalIndex++] = 'a';
            chars[animalIndex] = 't';
        }

        string str2 = new string(chars);
        System.Console.WriteLine(str2);

        // Keep the console window open in debug mode
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
  The quick brown fox jumped over the fence
  The quick brown cat jumped over the fence 
*/

L'exemple suivant est fourni pour les cas très rares où vous souhaitez modifier une chaîne sur place en utilisant du code non sécurisé, procédant ainsi comme avec les tableaux de caractères de style C. L'exemple indique comment accéder aux différents caractères « sur place » en utilisant le mot clé fixed. Il montre également un effet secondaire possible des opérations risquées réalisées sur les chaînes, lié à la façon dont le compilateur C# stocke (interne) les chaînes en interne. En général, il est préférable de ne pas utiliser cette technique, sauf en cas d'absolue nécessité.

class UnsafeString
{
    unsafe static void Main(string[] args)
    {
        // Compiler will store (intern) 
        // these strings in same location.
        string s1 = "Hello";
        string s2 = "Hello";

        // Change one string using unsafe code.
        fixed (char* p = s1)
        {
            p[0] = 'C';
        }

        //  Both strings have changed.
        Console.WriteLine(s1);
        Console.WriteLine(s2);

        // Keep console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

}

Voir aussi

Concepts

Guide de programmation C#

Référence

Chaînes (Guide de programmation C#)

Historique des modifications

Date	Historique	Raison
Juillet 2008	Apport de modifications importantes et ajout d'exemples de code pour améliorer l'exactitude et l'exhaustivité	Résolution des bogues de contenu.