Méthodes de string en C# : Split, Replace, Contains, IndexOf, Trim, Join et plus

System.String possède des dizaines de méthodes. Cette page couvre celles qui font l'essentiel du travail dans du vrai code, avec les options et les pièges qui comptent. Une règle s'applique à toutes : les chaînes sont immuables, donc chaque méthode renvoie une nouvelle chaîne (ou une valeur) et laisse l'originale inchangée. s.Trim(); seul sur sa ligne ne fait rien ; écrivez s = s.Trim();.

Split

Split découpe une chaîne en string[] à chaque séparateur :

using System;

class Program
{
    static void Main()
    {
        string csv = "apple,banana,cherry";
        string[] fruits = csv.Split(',');
        Console.WriteLine(fruits.Length);
        foreach (string f in fruits) Console.WriteLine(f);

        // Several separator characters
        string messy = "red;green, blue|yellow";
        string[] colors = messy.Split(new[] { ';', ',', '|' });
        Console.WriteLine(string.Join("/", colors));

        // A separator longer than one character
        string log = "INFO -> started -> ready";
        string[] steps = log.Split(new[] { " -> " }, StringSplitOptions.None);
        Console.WriteLine(string.Join("/", steps));
    }
}

Sortie :

3
apple
banana
cherry
red/green/ blue/yellow
INFO/started/ready

Remarquez " blue" : Split coupe exactement au séparateur et conserve les espaces. Deux options gèrent les nettoyages courants :

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string tags = "c#, ,dotnet,,  linq ";

        string[] raw = tags.Split(',');
        Console.WriteLine(raw.Length);   // empty and blank parts included

        string[] noEmpty = tags.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine(noEmpty.Length);

        string[] clean = tags.Split(',')
            .Select(t => t.Trim())
            .Where(t => t.Length > 0)
            .ToArray();
        Console.WriteLine(string.Join("|", clean));

        // Limit the number of parts: the last one keeps the rest
        string header = "Subject: Re: Meeting: Friday";
        string[] kv = header.Split(new[] { ':' }, 2);
        Console.WriteLine($"key=[{kv[0]}] value=[{kv[1].Trim()}]");

        string words = "one  two   three";
        Console.WriteLine(words.Split((char[])null, StringSplitOptions.RemoveEmptyEntries).Length); // split on any whitespace
    }
}

Sortie :

5
4
c#|dotnet|linq
key=[Subject] value=[Re: Meeting: Friday]
3

RemoveEmptyEntries supprime les parties de longueur nulle, mais pas celles qui ne contiennent que des espaces (" " a survécu ci-dessus). .NET 5 a ajouté StringSplitOptions.TrimEntries, et les deux peuvent se combiner : tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) donne le résultat propre en un seul appel. Passer null comme séparateur découpe sur n'importe quel espace blanc, ce qui est la façon habituelle de découper un texte en mots.

Découper sur un seul char (Split(',')) ne demande pas de tableau. Les surcharges qui prennent un char plus des options, ou une seule string, existent depuis .NET Core 2.0 ; les formes à tableau utilisées ci-dessus fonctionnent partout, y compris .NET Framework et Unity.

Replace

Replace remplace chaque occurrence d'un caractère ou d'une sous-chaîne :

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string phone = "555-123-4567";
        Console.WriteLine(phone.Replace("-", ""));       // remove
        Console.WriteLine(phone.Replace('-', '.'));      // char overload

        string text = "Cats and cats and CATS";
        Console.WriteLine(text.Replace("cats", "dogs")); // case-sensitive
        Console.WriteLine(text.Replace("cats", "dogs", StringComparison.OrdinalIgnoreCase));

        // Only the first occurrence
        var first = new Regex("cats", RegexOptions.IgnoreCase);
        Console.WriteLine(first.Replace(text, "dogs", 1));

        // Collapse repeated spaces
        Console.WriteLine(Regex.Replace("too    many   spaces", @"\s+", " "));
    }
}

Sortie :

5551234567
555.123.4567
Cats and dogs and CATS
dogs and dogs and dogs
dogs and cats and CATS
too many spaces

La surcharge avec un argument StringComparison est disponible sur .NET Core 2.0 et plus. Sur .NET Framework, le remplacement insensible à la casse se fait avec Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Remplacer par "" est la façon de supprimer des caractères, et enchaîner plusieurs appels à Replace convient pour quelques substitutions.

Contains, IndexOf, StartsWith et EndsWith

Ces méthodes recherchent. Contains répond oui ou non ; IndexOf et LastIndexOf renvoient une position, ou -1 en l'absence de correspondance ; StartsWith et EndsWith testent les extrémités.

using System;

class Program
{
    static void Main()
    {
        string subject = "Invoice #4471 overdue: please pay";

        Console.WriteLine(subject.Contains("overdue"));                    // True
        Console.WriteLine(subject.Contains("OVERDUE"));                    // False: case-sensitive
        Console.WriteLine(subject.Contains("OVERDUE", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine(subject.IndexOf("OVERDUE", StringComparison.OrdinalIgnoreCase) >= 0);

        Console.WriteLine(subject.IndexOf('#'));            // 8
        Console.WriteLine(subject.IndexOf("pay"));          // first "pay"
        Console.WriteLine(subject.LastIndexOf('e'));
        Console.WriteLine(subject.IndexOf("refund"));       // -1: not found
        Console.WriteLine(subject.IndexOf('e', 10));        // search from index 10

        string file = "photo.JPG";
        Console.WriteLine(file.EndsWith(".jpg"));           // False
        Console.WriteLine(file.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine("https://coddy.tech".StartsWith("https://"));
    }
}

Sortie :

True
False
True
True
8
30
28
-1
16
False
True
True

Toutes sont sensibles à la casse par défaut. Contains(string, StringComparison) existe sur .NET Core 2.1 et plus ; la forme IndexOf(...) >= 0 fonctionne sur toutes les versions, c'est pourquoi on la voit dans le code plus ancien. IndexOfAny(new[] { ',', ';' }) trouve le premier de plusieurs caractères.

Une remarque sur la culture : sans StringComparison, StartsWith, EndsWith, IndexOf(string) et CompareTo utilisent des règles sensibles à la culture, alors que Contains, Replace et IndexOf(char) comparent de façon ordinale. Passer explicitement StringComparison.Ordinal ou OrdinalIgnoreCase supprime l'ambiguïté, et les analyseurs de code le recommandent.

Trim, TrimStart et TrimEnd

Trim supprime les espaces blancs (espaces, tabulations, sauts de ligne) aux deux extrémités. TrimStart et TrimEnd les suppriment d'un seul côté. Si on leur donne des caractères, elles suppriment ceux-là à la place :

using System;

class Program
{
    static void Main()
    {
        string input = "  \t ana@example.com \n";
        Console.WriteLine($"[{input.Trim()}]");
        Console.WriteLine($"[{input.TrimStart()}]".Replace("\n", "\\n"));
        Console.WriteLine($"[{"  x  ".TrimEnd()}]");

        Console.WriteLine("***SALE***".Trim('*'));
        Console.WriteLine("007".TrimStart('0'));
        Console.WriteLine("path/to/dir///".TrimEnd('/'));
        Console.WriteLine("1,234.50 USD".TrimEnd(' ', 'U', 'S', 'D'));
    }
}

Sortie :

[ana@example.com]
[ana@example.com \n]
[  x]
SALE
7
path/to/dir
1,234.50

Trim ne touche qu'aux extrémités ; les espaces à l'intérieur de la chaîne sont conservés. TrimStart('0') sur "000" renvoie une chaîne vide, donc analysez les chaînes numériques avec int.Parse plutôt que de retirer les zéros à la main.

ToUpper et ToLower

using System;

class Program
{
    static void Main()
    {
        string name = "maya Lopez";
        Console.WriteLine(name.ToUpper());
        Console.WriteLine(name.ToLower());
        Console.WriteLine(name.ToUpperInvariant());

        // Capitalize the first letter
        string word = "coffee";
        string capital = char.ToUpper(word[0]) + word.Substring(1);
        Console.WriteLine(capital);
    }
}

Sortie :

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper et ToLower suivent la culture courante, donc en turc "i".ToUpper() donne un İ majuscule pointé, pas I. Pour les identifiants, les clés et les noms de fichiers, utilisez ToUpperInvariant et ToLowerInvariant. Pour comparer, utilisez une StringComparison au lieu de convertir la casse (voir chaînes). Pour mettre une majuscule à chaque mot, il existe CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), qui laisse toutefois intacts les mots déjà entièrement en majuscules.

PadLeft et PadRight

Le remplissage ajoute des caractères jusqu'à ce que la chaîne atteigne une largeur totale. C'est pratique pour une sortie à largeur fixe et pour compléter des codes avec des zéros :

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("42".PadLeft(6, '0'));
        Console.WriteLine("[" + "Tea".PadRight(8) + "]");
        Console.WriteLine("[" + "Tea".PadLeft(8) + "]");
        Console.WriteLine("Too long already".PadLeft(4));   // never truncates

        string[] items = { "Espresso", "Latte", "Mocha" };
        decimal[] prices = { 2.40m, 3.60m, 3.95m };
        for (int i = 0; i < items.Length; i++)
        {
            Console.WriteLine(items[i].PadRight(10, '.') + prices[i].ToString("F2").PadLeft(6));
        }
    }
}

Sortie :

000042
[Tea     ]
[     Tea]
Too long already
Espresso..  2.40
Latte.....  3.60
Mocha.....  3.95

L'alignement de l'interpolation ({name,-10}) fait le même travail directement dans le texte.

Join et Concat

string.Join place un séparateur entre les éléments de n'importe quelle collection. string.Concat assemble sans séparateur :

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var guests = new List<string> { "Ana", "Ben", "Chloe" };
        Console.WriteLine(string.Join(", ", guests));
        Console.WriteLine(string.Join(" + ", new[] { 1, 2, 3 }));   // any type
        Console.WriteLine(string.Join(",", new string[0]) == "");    // empty input: empty string

        Console.WriteLine(string.Concat("2026", "-", "09"));
        Console.WriteLine(string.Concat(guests));

        // "A, B and C"
        string list = guests.Count > 1
            ? string.Join(", ", guests.GetRange(0, guests.Count - 1)) + " and " + guests[guests.Count - 1]
            : string.Join("", guests);
        Console.WriteLine(list);
    }
}

Sortie :

Ana, Ben, Chloe
1 + 2 + 3
True
2026-09
AnaBenChloe
Ana, Ben and Chloe

Join est la bonne façon de construire une liste délimitée : il n'y a pas de séparateur final à retirer, et le résultat est construit en un seul passage. La méthode appelle ToString() sur chaque élément, elle fonctionne donc aussi avec des nombres et des objets.

Reverse, Insert et Remove

Il n'existe pas de méthode string.Reverse qui renvoie une chaîne. Les deux approches habituelles :

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string word = "stressed";

        char[] chars = word.ToCharArray();
        Array.Reverse(chars);
        Console.WriteLine(new string(chars));

        Console.WriteLine(new string(word.Reverse().ToArray()));   // LINQ

        string racecar = "Racecar";
        string lower = racecar.ToLowerInvariant();
        Console.WriteLine(lower == new string(lower.Reverse().ToArray()));  // palindrome?

        Console.WriteLine("2026-09".Insert(4, "/Q3"));     // insert at an index
        Console.WriteLine("Hello, World".Remove(5));        // everything from index 5 removed
        Console.WriteLine("Hello, World".Remove(5, 2));     // 2 chars removed at 5
    }
}

Sortie :

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() seul renvoie un IEnumerable<char>, pas une chaîne ; l'afficher montre un nom de type. Les deux méthodes inversent des unités de code UTF-16, ce qui casse les caractères faits de deux unités (la plupart des emoji) et les lettres avec accents combinants.

Référence rapide