Guide pratique pour modifier du contenu de chaîne en C#How to: Modify string contents in C#

Cet article présente plusieurs techniques pour produire un string en modifiant un string existant.This article demonstrates several techniques to produce a string by modifying an existing string. Toutes les techniques présentées retournent le résultat des modifications sous la forme d’un nouvel objet string.All the techniques demonstrated return the result of the modifications as a new string object. Pour illustrer clairement ceci, tous les exemples stockent le résultat dans une nouvelle variable.To clearly demonstrate this, the examples all store the result in a new variable. Vous pouvez ensuite examiner le string d’origine et le string résultant de la modification quand vous exécutez chaque exemple.You can then examine both the original string and the string resulting from the modification when you run each example.

Note

Les exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive.Select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Plusieurs techniques sont présentées dans cet article.There are several techniques demonstrated in this article. Vous pouvez remplacer du texte existant.You can replace existing text. Vous pouvez rechercher des modèles et remplacer le texte correspondant par un autre texte.You can search for patterns and replace matching text with other text. Vous pouvez traiter une chaîne en tant que séquence de caractères.You can treat a string as a sequence of characters. Vous pouvez également utiliser des méthodes pratiques qui suppriment les espaces blancs.You can also use convenience methods that remove white space. Choisissez les techniques les mieux adaptées à votre scénario.You should choose the techniques that most closely match your scenario.

Remplacer du texteReplace text

Le code suivant crée une chaîne en remplaçant le texte existant par un substitut.The following code creates a new string by replacing existing text with a substitute.

string source = "The mountains are behind the clouds today.";

// Replace one substring with another with String.Replace.
// Only exact matches are supported.
var replacement = source.Replace("mountains", "peaks");
Console.WriteLine($"The source string is <{source}>");
Console.WriteLine($"The updated string is <{replacement}>");

Le code précédent illustre la propriété immuable des chaînes.The preceding code demonstrates this immutable property of strings. Vous pouvez voir dans l’exemple précédent que la chaîne d’origine, source, n’est pas modifiée.You can see in the preceding example that the original string, source, is not modified. La méthode String.Replace crée un string contenant les modifications.The String.Replace method creates a new string containing the modifications.

La méthode Replace peut remplacer des chaînes ou des caractères uniques.The Replace method can replace either strings or single characters. Dans les deux cas, toutes les occurrences du texte recherché sont remplacées.In both cases, every occurrence of the sought text is replaced. L’exemple suivant remplace tous les caractères ' ' par '_' :The following example replaces all ' ' characters with '_':

string source = "The mountains are behind the clouds today.";

// Replace all occurrences of one char with another.
var replacement = source.Replace(' ', '_');
Console.WriteLine(source);
Console.WriteLine(replacement);

La chaîne source ne change pas, et une nouvelle chaîne est retournée avec le remplacement.The source string is unchanged, and a new string is returned with the replacement.

Supprimer les espaces blancsTrim white space

Vous pouvez utiliser les méthodes String.Trim, String.TrimStart et String.TrimEnd pour supprimer les espaces blancs de début ou de fin.You can use the String.Trim, String.TrimStart, and String.TrimEnd methods to remove any leading or trailing white space. Le code suivant montre un exemple de chaque.The following code shows an example of each. La chaîne source ne change pas. Ces méthodes retournent une nouvelle chaîne avec le contenu modifié.The source string does not change; these methods return a new string with the modified contents.

// Remove trailing and leading white space.
string source = "    I'm wider than I need to be.      ";
// Store the results in a new string variable.
var trimmedResult = source.Trim();
var trimLeading = source.TrimStart();
var trimTrailing = source.TrimEnd();
Console.WriteLine($"<{source}>");
Console.WriteLine($"<{trimmedResult}>");
Console.WriteLine($"<{trimLeading}>");
Console.WriteLine($"<{trimTrailing}>");

Supprimer du texteRemove text

Vous pouvez supprimer du texte d’une chaîne à l’aide de la méthode String.Remove.You can remove text from a string using the String.Remove method. Cette méthode supprime un certain nombre de caractères en commençant à un index spécifique.This method removes a number of characters starting at a specific index. L’exemple suivant montre comment utiliser String.IndexOf suivi de Remove pour supprimer le texte d’une chaîne :The following example shows how to use String.IndexOf followed by Remove to remove text from a string:

string source = "Many mountains are behind many clouds today.";
// Remove a substring from the middle of the string.
string toRemove = "many ";
string result = string.Empty;
int i = source.IndexOf(toRemove);
if (i >= 0)
{
    result= source.Remove(i, toRemove.Length);
}
Console.WriteLine(source);
Console.WriteLine(result);

Remplacer du texte correspondant à un modèleReplace matching patterns

Vous pouvez utiliser des expressions régulières pour remplacer du texte correspondant à un modèle par un autre texte, éventuellement défini par un modèle.You can use regular expressions to replace text matching patterns with new text, possibly defined by a pattern. L’exemple suivant utilise la classe System.Text.RegularExpressions.Regex pour trouver un modèle dans une chaîne source et le remplacer par du texte dont la casse est correcte.The following example uses the System.Text.RegularExpressions.Regex class to find a pattern in a source string and replace it with proper capitalization. La méthode Regex.Replace(String, String, MatchEvaluator, RegexOptions) accepte dans ses arguments une fonction qui fournit la logique du remplacement.The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method takes a function that provides the logic of the replacement as one of its arguments. Dans cet exemple, la fonction LocalReplaceMatchCase est une fonction locale déclarée à l’intérieur de l’exemple de méthode.In this example, that function, LocalReplaceMatchCase is a local function declared inside the sample method. LocalReplaceMatchCase utilise la classe System.Text.StringBuilder pour générer la chaîne de remplacement avec la casse correcte.LocalReplaceMatchCase uses the System.Text.StringBuilder class to build the replacement string with proper capitalization.

Les expressions régulières sont plus utiles pour rechercher et remplacer du texte qui suit un modèle que du texte connu.Regular expressions are most useful for searching and replacing text that follows a pattern, rather than known text. Pour plus d’informations, consultez Guide pratique pour faire des recherches dans des chaînes.See How to: search strings for more details. Le modèle de recherche, « the\s », recherche le mot « the » suivi d’un espace blanc.The search pattern, "the\s" searches for the word "the" followed by a white-space character. Cette partie du modèle permet d’exclure le mot « there » qui figure dans la chaîne source.That part of the pattern ensures that it doesn't match "there" in the source string. Pour plus d’informations sur les éléments du langage des expressions régulières, consultez Langage des expressions régulières - Aide-mémoire.For more information on regular expression language elements, see Regular Expression Language - Quick Reference.

string source = "The mountains are still there behind the clouds today.";

// Use Regex.Replace for more flexibility. 
// Replace "the" or "The" with "many" or "Many".
// using System.Text.RegularExpressions
string replaceWith = "many ";
source = System.Text.RegularExpressions.Regex.Replace(source, "the\\s", LocalReplaceMatchCase, 
    System.Text.RegularExpressions.RegexOptions.IgnoreCase);
Console.WriteLine(source);

string LocalReplaceMatchCase(System.Text.RegularExpressions.Match matchExpression)
{
    // Test whether the match is capitalized
    if (Char.IsUpper(matchExpression.Value[0]))
    {
        // Capitalize the replacement string
        System.Text.StringBuilder replacementBuilder = new System.Text.StringBuilder(replaceWith);
        replacementBuilder[0] = Char.ToUpper(replacementBuilder[0]);
        return replacementBuilder.ToString();
    }
    else
    {
        return replaceWith;
    }
}

La méthode StringBuilder.ToString retourne une chaîne immuable avec le contenu dans l’objet StringBuilder.The StringBuilder.ToString method returns an immutable string with the contents in the StringBuilder object.

Modification de caractères individuelsModifying individual characters

Vous pouvez générer un tableau de caractères à partir d’une chaîne, modifier le contenu du tableau, puis créer une autre chaîne à partir du contenu modifié du tableau.You can produce a character array from a string, modify the contents of the array, and then create a new string from the modified contents of the array.

L’exemple suivant montre comment remplacer un jeu de caractères dans une chaîne.The following example shows how to replace a set of characters in a string. Tout d’abord, il utilise la méthode ToCharArray() pour créer un tableau de caractères.First, it uses the ToCharArray() method to create an array of characters. Il utilise la méthode IndexOf pour trouver l’index de départ du mot « fox ».It uses the IndexOf method to find the starting index of the word "fox." Les trois caractères suivants sont remplacés par un autre mot.The next three characters are replaced with a different word. Enfin, une nouvelle chaîne est construite à partir du tableau de caractères mis à jour.Finally, a new string is constructed from the updated character array.

string phrase = "The quick brown fox jumps over the fence";
Console.WriteLine(phrase);

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

string updatedPhrase = new string(phraseAsChars);
Console.WriteLine(updatedPhrase);

Modifications unsafe d’une chaîneUnsafe modifications to string

Le code unsafe vous permet de modifier une chaîne « sur place » une fois celle-ci créée.Using unsafe code, you can modify a string "in place" after it has been created. Ce code ignore les nombreuses fonctionnalités de .NET conçues pour réduire certains types de bogues dans le code.Unsafe code bypasses many of the features of .NET designed to minimize certain types of bugs in code. Vous devez utiliser du code unsafe pour modifier une chaîne sur place, car la classe string est par conception un type immuable.You need to use unsafe code to modify a string in place because the string class is designed as an immutable type. Une fois la chaîne créée, sa valeur ne change pas.Once it has been created, its value does not change. Pour contourner cette propriété, le code unsafe accède à la mémoire utilisée par un string et la modifie sans recourir aux méthodes string normales.Unsafe code circumvents this property by accessing and modifying the memory used by a string without using normal string methods. L’exemple suivant est fourni dans les rares cas où vous souhaiteriez modifier une chaîne sur place à l’aide de code unsafe.The following example is provided for those rare situations where you want to modify a string in-place using unsafe code. L’exemple montre comment utiliser le mot clé fixed.The example shows how to use the fixed keyword. Le mot clé fixed empêche le garbage collector (GC) de déplacer l’objet string en mémoire pendant que le code accède à la mémoire à l’aide du pointeur unsafe.The fixed keyword prevents the garbage collector (GC) from moving the string object in memory while code accesses the memory using the unsafe pointer. Il montre également un effet secondaire possible des opérations risquées effectuées sur les chaînes, lié à la façon dont le compilateur C# stocke (intègre) les chaînes en interne.It also demonstrates one possible side effect of unsafe operations on strings that results from the way that the C# compiler stores (interns) strings internally. En général, il est préférable de ne pas utiliser cette technique, sauf en cas d’absolue nécessité.In general, you shouldn't use this technique unless it is absolutely necessary. Pour plus d’informations, consultez les articles sur unsafe et fixed.You can learn more in the articles on unsafe and fixed. Les informations de référence sur l’API pour Intern comprennent des informations sur la centralisation des chaînes.The API reference for Intern includes information on string interning.

unsafe
{
    // Compiler will store (intern) 
    // these strings in same location.
    string helloOne = "Hello";
    string helloTwo = "Hello";

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

    //  Both strings have changed.
    Console.WriteLine(helloOne);
    Console.WriteLine(helloTwo);
}

Vous pouvez essayer ces exemples en examinant le code dans notre dépôt GitHub.You can try these samples by looking at the code in our GitHub repository. Vous pouvez aussi télécharger les exemples sous forme de fichier zip.Or you can download the samples as a zip file.

Voir aussiSee also