Comment modifier du contenu de chaîne en C#

Cet article présente plusieurs techniques pour produire un string en modifiant un string existant. Toutes les techniques présentées retournent le résultat des modifications sous la forme d’un nouvel objet string. Pour démontrer que les chaînes d’origine et modifiées sont des instances distinctes, les exemples stockent le résultat dans une nouvelle variable. Vous pouvez examiner la string d’origine et la nouvelle string modifiée lorsque vous exécutez chaque exemple.

Plusieurs techniques sont présentées dans cet article. Vous pouvez remplacer du texte existant. Vous pouvez rechercher des modèles et remplacer le texte correspondant par un autre texte. Vous pouvez traiter une chaîne en tant que séquence de caractères. Vous pouvez également utiliser des méthodes pratiques qui suppriment les espaces blancs. Choisissez les techniques les mieux adaptées à votre scénario.

Remplacer du texte

Le code suivant crée une chaîne en remplaçant le texte existant par un substitut.

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. Vous pouvez voir dans l’exemple précédent que la chaîne d’origine, source, n’est pas modifiée. La méthode String.Replace crée un string contenant les modifications.

La méthode Replace peut remplacer des chaînes ou des caractères uniques. Dans les deux cas, toutes les occurrences du texte recherché sont remplacées. L’exemple suivant remplace tous les caractères ' ' par '_' :

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.

Supprimer les espaces blancs

Vous pouvez utiliser les méthodes String.Trim, String.TrimStart et String.TrimEnd pour supprimer les espaces blancs de début ou de fin. Le code suivant montre un exemple de chaque. La chaîne source ne change pas. Ces méthodes retournent une nouvelle chaîne avec le contenu modifié.

// 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 texte

Vous pouvez supprimer du texte d’une chaîne à l’aide de la méthode String.Remove. Cette méthode supprime un certain nombre de caractères en commençant à un index spécifique. L’exemple suivant montre comment utiliser String.IndexOf suivi de Remove pour supprimer le texte d’une chaîne :

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èle

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. 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. La méthode Regex.Replace(String, String, MatchEvaluator, RegexOptions) accepte dans ses arguments une fonction qui fournit la logique du remplacement. Dans cet exemple, la fonction LocalReplaceMatchCase est une fonction locale déclarée à l’intérieur de l’exemple de méthode. LocalReplaceMatchCase utilise la classe System.Text.StringBuilder pour générer la chaîne de remplacement avec la casse correcte.

Les expressions régulières sont plus utiles pour rechercher et remplacer du texte qui suit un modèle que du texte connu. Pour plus d’informations, consultez Comment rechercher des chaînes. Le modèle de recherche, « the\s », recherche le mot « the » suivi d’un espace blanc. Cette partie du modèle permet d’exclure le mot « there » qui figure dans la chaîne source. 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.

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.

Modification de caractères individuels

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.

L’exemple suivant montre comment remplacer un jeu de caractères dans une chaîne. Tout d’abord, il utilise la méthode String.ToCharArray() pour créer un tableau de caractères. Il utilise la méthode IndexOf pour rechercher l’index de départ du mot « fox ». Les trois caractères suivants sont remplacés par un autre mot. Enfin, une nouvelle chaîne est construite à partir du tableau de caractères mis à jour.

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);

Créer du contenu de chaîne par programmation

Étant donné que les chaînes sont immuables, les exemples précédents créent tous des chaînes temporaires ou des tableaux de caractères. Dans les scénarios hautes performances, il peut être souhaitable d’éviter ces allocations de tas. .NET Core fournit une méthode String.Create qui vous permet de remplir par programmation le contenu des caractères d’une chaîne via un rappel tout en évitant les allocations de chaînes temporaires intermédiaires.

// constructing a string from a char array, prefix it with some additional characters
char[] chars = { 'a', 'b', 'c', 'd', '\0' };
int length = chars.Length + 2;
string result = string.Create(length, chars, (Span<char> strContent, char[] charArray) =>
{
    strContent[0] = '0';
    strContent[1] = '1';
    for (int i = 0; i < charArray.Length; i++)
    {
        strContent[i + 2] = charArray[i];
    }
});

Console.WriteLine(result);

Vous pouvez modifier une chaîne dans un bloc fixe avec du code non sécurisé, mais il est fortement déconseillé de modifier le contenu de la chaîne après sa création. Cela brisera les choses de manière imprévisible. Par exemple, si quelqu’un interne une chaîne dont le contenu est identique au vôtre, il obtiendra votre copie et ne s’attendra pas à ce que vous modifiiez sa chaîne.

Voir aussi

• Expressions régulières .NET
• Langage des expressions régulières - Aide-mémoire