String en C# : Length, comparaison, caractères d'échappement, chaînes verbatim et multilignes

Une string en C# est une suite de caractères UTF-16 (des valeurs char). C'est un type référence, mais elle se comporte comme une valeur sur les points qui comptent : elle est immuable, et == compare le texte plutôt que l'identité de l'objet. string est le mot-clé C# du type .NET System.String ; les deux sont interchangeables.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Sortie :

Porto
5
0
*****
hi
Porto has 5 letters

Les chaînes sont immuables

Aucune méthode ne modifie une chaîne sur place. ToUpper, Replace, Trim et toutes les autres méthodes renvoient une nouvelle chaîne et laissent l'originale intacte. Oublier d'utiliser la valeur renvoyée est un bug très courant avec les chaînes :

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Sortie :

[  maya  ]
[MAYA]
tea
tea and cake

L'immuabilité rend les chaînes sûres à partager entre threads et à utiliser comme clés de dictionnaire. Le coût est que construire une chaîne morceau par morceau dans une boucle crée une nouvelle chaîne à chaque étape ; pour cela, utilisez StringBuilder.

Longueur et indexation

Length est une propriété (sans parenthèses). L'indexeur s[i] renvoie le char à la position i, en comptant à partir de 0, et il est en lecture seule :

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Sortie :

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 et plus acceptent aussi un index depuis la fin : code[^1] est le dernier caractère, comme code[code.Length - 1]. Pour prendre plusieurs caractères à la fois, voir substring.

Length compte des unités de code UTF-16, pas ce qu'un lecteur voit comme des caractères. La plupart des lettres de la plupart des langues occupent une unité, mais les emoji et quelques écritures rares en utilisent deux (une paire de substitution), donc "👍".Length vaut 2.

Comparer des chaînes

== et != comparent les caractères, en tenant compte de la casse. Pour tout le reste, passez une valeur StringComparison qui indique comment comparer :

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Sortie :

False
False
True
True
apple first
True
False
False
True

Quelle comparaison utiliser :

• Ordinal compare les codes numériques des caractères. C'est rapide, prévisible et identique sur chaque machine. Utilisez-la pour les identifiants, les noms de fichiers, les clés, les valeurs de protocole et tout ce qui n'est pas montré à une personne.
• OrdinalIgnoreCase fait la même chose en ignorant la casse. C'est le bon choix pour les tests insensibles à la casse, comme les extensions de fichiers ou les en-têtes HTTP.
• CurrentCulture (et CurrentCultureIgnoreCase) suit les règles de la langue de l'utilisateur, donc trie les mots comme le ferait un dictionnaire dans cette langue. Utilisez-la pour trier des listes affichées aux utilisateurs.
• InvariantCulture applique des règles culturelles qui ne dépendent pas des paramètres de langue de l'utilisateur. Elle dépend quand même de la bibliothèque de globalisation : le .NET moderne utilise ICU, .NET Framework utilise NLS de Windows, et les deux peuvent ordonner certaines chaînes différemment.

string.Compare(a, b) et a.CompareTo(b) sans StringComparison utilisent la culture courante, si bien que leurs résultats varient d'une machine à l'autre. Évitez de comparer avec a.ToLower() == b.ToLower() : cela alloue deux nouvelles chaînes et donne de mauvaises réponses dans certaines cultures (le i avec et sans point du turc est le cas classique).

Appeler a.Equals(b) quand a vaut null lève une NullReferenceException, alors que a == b et la méthode statique string.Equals(a, b) gèrent null sans problème.

Caractères d'échappement

Dans un littéral de chaîne ordinaire, une barre oblique inverse commence une séquence d'échappement :

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Sortie :

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

Une séquence non reconnue comme "\d" est une erreur de compilation (CS1009, unrecognized escape sequence) ; c'est ce qui arrive quand un chemin Windows ou une expression régulière est écrit comme une chaîne ordinaire.

Chaînes verbatim et chaînes multilignes

Préfixer un littéral par @ le rend verbatim : les barres obliques inverses sont des caractères littéraux, et la chaîne peut s'étendre sur plusieurs lignes. Le seul échappement restant est "", qui produit un guillemet double.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Sortie :

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

Une chaîne verbatim multiligne inclut tout ce qui se trouve entre les guillemets, y compris l'indentation des lignes suivantes, c'est pourquoi on les écrit en général collées à la marge comme ci-dessus. Les sauts de ligne qu'elle contient sont ceux du fichier source, donc un fichier enregistré avec des fins de ligne Windows produit \r\n.

C# 11 a ajouté les littéraux de chaîne bruts (raw string literals), qui résolvent ces deux problèmes. Ils commencent et se terminent par trois guillemets doubles ou plus, n'ont besoin d'aucun échappement et retirent l'indentation correspondant à celle des guillemets fermants :

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

Si le contenu lui-même contient """, commencez et terminez par quatre guillemets. Les littéraux bruts se combinent aussi avec l'interpolation ($"""...""") ; voir interpolation de chaînes.

Null, vide et espaces

Une variable string peut valoir null (aucune chaîne), être vide ("", longueur 0) ou ne contenir que des espaces. Deux méthodes statiques vérifient ces cas sans risquer de NullReferenceException :

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Sortie :

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Pour valider une saisie utilisateur, string.IsNullOrWhiteSpace est presque toujours celle qu'il vous faut. string.Empty et "" sont la même valeur ; lequel écrire est une question de style.

Parcourir les caractères

Une chaîne est énumérable, donc foreach visite chaque char. Le type char possède des méthodes statiques pour classer les caractères :

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Sortie :

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Assembler des chaînes

+ concatène, et fonctionne avec n'importe quel type de l'autre côté (il appelle ToString()). Pour combiner beaucoup de valeurs, préférez l'interpolation ou string.Join :

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Sortie :

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

Les deux dernières lignes montrent un piège de priorité : + est évalué de gauche à droite, donc dès que la partie gauche est une chaîne, chaque + suivant est une concaténation. Mettez l'arithmétique entre parenthèses dans une concaténation.