Chaînes (Guide de programmation C#)

Une chaîne est un objet de type String dont la valeur est du texte. En interne, le texte est stocké sous la forme d’une collection séquentielle en lecture seule d’objets Char. Il n’existe aucun caractère de fin Null à la fin d’une chaîne C# ; par conséquent, une chaîne C# peut contenir n’importe quel nombre de caractères Null incorporés ('\0'). La propriété Length d’une chaîne représente le nombre d’objets Char qu’elle contient, et non pas le nombre de caractères Unicode. Pour accéder à des points de code Unicode individuels dans une chaîne, utilisez l’objet StringInfo.

String et System. String

En C#, le mot clé string est un alias pour String. Par conséquent, String et string sont équivalents, même s’il est recommandé d’utiliser l’alias fourni, string car il fonctionne même sans using System; . La classe String fournit de nombreuses méthodes pour créer, manipuler et comparer des chaînes en toute sécurité. En outre, le langage C# surcharge certains opérateurs pour simplifier les opérations de chaînes courantes. Pour plus d’informations sur le mot clé, voir chaîne. Pour plus d’informations sur le type et ses méthodes, consultez String.

Déclaration et initialisation de chaînes

Vous pouvez déclarer et initialiser des chaînes de différentes manières, comme illustré dans l’exemple suivant :

// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

// Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Notez que vous n’utilisez pas l’opérateur new pour créer un objet String, excepté lors de l’initialisation de la chaîne avec un tableau de caractères.

Initialisez une chaîne avec la valeur constante Empty pour créer un objet String dont la chaîne est de longueur nulle. La représentation de littéral de chaîne d’une chaîne de longueur nulle est "". En initialisant les chaînes avec la valeur Empty au lieu de null, vous pouvez réduire les risques de levée de l’exception NullReferenceException. Utilisez la méthode statique IsNullOrEmpty(String) pour vérifier la valeur d’une chaîne avant de tenter d’y accéder.

Immuabilité des objets String

Les objets String sont immuables : ils ne peuvent pas être modifiés une fois qu’ils ont été créés. Toutes les méthodes String et tous les opérateurs C# qui semblent modifier une chaîne retournent en fait les résultats dans un nouvel objet string. Dans l’exemple suivant, lorsque les contenus de s1 et s2 sont concaténés pour former une chaîne unique, les deux chaînes d’origine restent inchangées. L’opérateur += crée une nouvelle chaîne qui contient le contenu combiné. Ce nouvel objet est assigné à la variable s1 et l’objet d’origine qui a été assigné à s1 est libéré pour la garbage collection, car aucune autre variable ne le référence.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Étant donné qu’une « modification » de chaîne correspond en fait à la création d’une nouvelle chaîne, vous devez être prudent lorsque vous créez des références aux chaînes. Si vous créez une référence à une chaîne, puis « modifiez » la chaîne d’origine, la référence continue à pointer vers l’objet d’origine au lieu du nouvel objet créé lors de la modification de la chaîne. Le code suivant illustre ce comportement :

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Pour plus d’informations sur la création de chaînes basées sur des modifications telles que les opérations de recherche et de remplacement sur la chaîne d’origine, consultez Comment modifier le contenud’une chaîne.

Littéraux de chaînes normales et textuelles

Utilisez des littéraux de chaînes normales lorsque vous devez incorporer des caractères d’échappement fournis par C#, comme illustré dans l’exemple suivant :

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
  Row 1
  Row 2
  Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Utilisez des chaînes textuelles pour plus de commodité et pour une meilleure lisibilité lorsque le texte de la chaîne contient des barres obliques inverses, par exemple dans les chemins d’accès. Étant donné que les chaînes textuelles conservent les caractères de nouvelle ligne dans le texte de la chaîne, elles peuvent servir à initialiser des chaînes multilignes. Utilisez des guillemets doubles pour incorporer des guillemets dans une chaîne textuelle. L’exemple suivant montre certaines utilisations courantes des chaînes textuelles :

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
   Thus on mine arm, most soothing sweet it is
   To sit beside our Cot,...
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Séquences d’échappement de chaîne

Séquence d'échappement Nom du caractère Codage Unicode
\' Guillemet simple 0x0027
\" Guillemet double 0x0022
\\ Barre oblique inverse 0x005C
\0 Null 0x0000
\a Alerte 0x0007
\b Retour arrière 0x0008
\f Saut de page 0x000C
\n Nouvelle ligne 0x000A
\r Retour chariot 0x000D
\t Tabulation horizontale 0x0009
\v Tabulation verticale 0x000B
\u Séquence d’échappement Unicode (UTF-16) \uHHHH (plage : 0000-FFFF ; exemple : \u00E7 = "ç")
\U Séquence d’échappement Unicode (UTF-32) \U00HHHHHH (plage : 000000-10FFFF ; exemple : \U0001F47D = "&#x1F47D ;")
\x Séquence d’échappement Unicode similaire à "\u", mais avec une longueur variable \xH[H][H][H] (plage : 0-FFFF ; exemple : \x00E7 or \x0E7 ou \xE7 = "ç")

Avertissement

Quand vous utilisez la séquence d’échappement \x et spécifiez moins de 4 chiffres hexadécimaux, si les caractères qui suivent immédiatement la séquence d’échappement sont des chiffres hexadécimaux valides (par ex. 0-9, A-F et a-f), ils sont interprétés comme faisant partie de la séquence d’échappement. Par exemple, \xA1 donne "¡", qui est le point de code U+00A1. Toutefois, si le caractère suivant est « A » ou « a », la séquence d’échappement est plutôt être interprétée comme étant \xA1A et donne "ਚ", qui est le point de code U+0A1A. Dans ce cas, la spécification des 4 chiffres hexadécimaux (par ex. \x00A1) empêche toute mauvaise interprétation possible.

Notes

Au moment de la compilation, les chaînes textuelles sont converties en chaînes normales avec les mêmes séquences d’échappement. Par conséquent, si vous affichez une chaîne textuelle dans la fenêtre Espion du débogueur, vous verrez les caractères d’échappement qui ont été ajoutés par le compilateur et non la version textuelle de votre code source. Par exemple, la chaîne textuelle @"C:\files.txt" s’affiche dans la fenêtre Espion en tant que "C:\\files.txt".

Chaînes de format

Une chaîne de format est une chaîne dont le contenu est déterminé de façon dynamique lors de l’exécution. Les chaînes de format sont créées en incorporant des expressions interpolées ou des espaces réservés à l’intérieur d’accolades dans une chaîne. Tous les éléments à l’intérieur des accolades ({...}) seront convertis en une valeur et affichés sous forme d’une chaîne mise en forme lors de l’exécution. Il existe deux méthodes pour créer des chaînes de format : l’interpolation de chaîne et la mise en forme composite.

Interpolation de chaîne

Disponible dans C# 6.0 et versions ultérieures, les chaînes interpolées sont identifiées par le caractère spéciale $ et incluent des expressions interpolées entre accolades. Si vous ne connaissez pas l’interpolation de chaîne, consultez le tutoriel interactif Interpolation de chaînes en C# pour obtenir un aperçu.

Utilisez l’interpolation de chaîne pour améliorer la lisibilité et la maintenance de votre code. L’interpolation de chaîne permet d’obtenir les mêmes résultats que la méthode String.Format, mais avec plus de facilité d’utilisation et de clarté.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today.

À compter de C# 10, vous pouvez utiliser l’interpolation de chaîne pour initialiser une chaîne constante lorsque toutes les expressions utilisées pour les espaces réservés sont également des chaînes constantes.

Mise en forme composite

String.Format utilise des espaces réservés entre accolades pour créer une chaîne de format. Cet exemple renvoie une sortie similaire à la méthode d’interpolation de chaîne utilisée ci-dessus.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

Pour plus d’informations sur la mise en forme des types .NET, consultez Mise en forme des types dans .NET.

Sous-chaînes

Une sous-chaîne est une séquence de caractères qui est contenue dans une chaîne. Utilisez la méthode Substring pour créer une chaîne à partir d’une partie de la chaîne d’origine. Vous pouvez rechercher une ou plusieurs occurrences d’une sous-chaîne en utilisant la méthode IndexOf. Utilisez la méthode Replace pour remplacer toutes les occurrences d’une sous-chaîne spécifiée par une nouvelle chaîne. Comme la méthode Substring, Replace retourne en fait une nouvelle chaîne et ne modifie pas la chaîne d’origine. Pour plus d’informations, consultez Comment rechercher des chaînes et Comment modifier le contenu d’une chaîne.

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Accès aux caractères individuels

Vous pouvez utiliser la notation de tableau avec une valeur d’index pour obtenir un accès en lecture seule aux caractères individuels, comme dans l’exemple suivant :

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Si les méthodesString ne fournissent pas la fonctionnalité nécessaire pour modifier les caractères individuels d’une chaîne, vous pouvez utiliser un objet StringBuilder pour modifier les caractères individuels « sur place », puis créer une chaîne pour stocker les résultats en utilisant les méthodes StringBuilder. Dans l’exemple suivant, supposons que vous devez modifier la chaîne d’origine d’une façon particulière, puis stocker les résultats pour une utilisation ultérieure :

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?

Chaînes Null et chaînes vides

Une chaîne vide est une instance d’un objet System.String qui contient zéro caractère. Les chaînes vides sont souvent utilisées dans divers scénarios de programmation pour représenter un champ de texte vide. Vous pouvez appeler des méthodes sur des chaînes vides, car ce sont des objets System.String. Les chaînes vides sont initialisées comme suit :

string s = String.Empty;  

En revanche, une chaîne null ne fait pas référence à une instance d’un objet System.String, et toute tentative pour appeler une méthode sur une chaîne null lève une exception NullReferenceException. Toutefois, vous pouvez utiliser des chaînes Null dans les opérations de comparaison et de concaténation avec d’autres chaînes. Les exemples suivants illustrent certains cas dans lesquels une référence à une chaîne Null provoque ou non la levée d’une exception :

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = String.Empty;

    string tempStr = str + nullStr;
    // Output of the following line: hello
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // Output of the following line: False
    Console.WriteLine(b);

    // The following line creates a new empty string.
    string newStr = emptyStr + nullStr;

    // Null strings and empty strings behave differently. The following
    // two lines display 0.
    Console.WriteLine(emptyStr.Length);
    Console.WriteLine(newStr.Length);
    // The following line raises a NullReferenceException.
    //Console.WriteLine(nullStr.Length);

    // The null character can be displayed and counted, like other chars.
    string s1 = "\x0" + "abc";
    string s2 = "abc" + "\x0";
    // Output of the following line: * abc*
    Console.WriteLine("*" + s1 + "*");
    // Output of the following line: *abc *
    Console.WriteLine("*" + s2 + "*");
    // Output of the following line: 4
    Console.WriteLine(s2.Length);
}

Utilisation de StringBuilder pour créer rapidement une chaîne

Les opérations Strings dans .NET sont hautement optimisées et, dans la plupart des cas, n’ont pas d’incidence significative sur les performances. Toutefois, dans certains scénarios, notamment dans le cas de boucles serrées qui s’exécutent plusieurs centaines voire milliers de fois, les opérations String peuvent affecter les performances. La classe StringBuilder crée un tampon de chaîne qui offre de meilleures performances si votre programme exécute de nombreuses manipulations de chaînes. La chaîne StringBuilder vous permet également de réassigner des caractères individuels, une fonctionnalité non prise en charge par les types de données string intégrés. Ce code, par exemple, modifie le contenu d’une chaîne sans créer de nouvelle chaîne :

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
System.Console.ReadLine();

//Outputs Cat: the ideal pet

Dans cet exemple, un objet StringBuilder est utilisé pour créer une chaîne à partir d’un ensemble de types numériques :

using System;
using System.Text;

namespace CSRefStrings
{
    class TestStringBuilder
    {
        static void Main()
        {
            var sb = new StringBuilder();

            // Create a string composed of numbers 0 - 9
            for (int i = 0; i < 10; i++)
            {
                sb.Append(i.ToString());
            }
            Console.WriteLine(sb);  // displays 0123456789

            // Copy one character of the string (not possible with a System.String)
            sb[0] = sb[9];

            Console.WriteLine(sb);  // displays 9123456789
            Console.WriteLine();
        }
    }
}

Chaînes, méthodes d’extension et LINQ

Étant donné que le type String implémente IEnumerable<T>, vous pouvez utiliser les méthodes d’extension définies dans la classe Enumerable sur des chaînes. Pour éviter une surcharge visuelle, ces méthodes sont exclues d’IntelliSense pour le type String, mais elles restent néanmoins disponibles. Vous pouvez également utiliser des expressions de requête LINQ sur des chaînes. Pour plus d’informations, consultez LINQ et Strings.

Rubrique Description
Comment modifier le contenu d’une chaîne Illustre les techniques permettant de transformer des chaînes et de modifier le contenu de chaînes.
Comment comparer des chaînes Montre comment effectuer des comparaisons de chaînes ordinales et spécifiques à la culture.
Concaténation de plusieurs chaînes Illustre différentes manières de joindre plusieurs chaînes pour en former une.
Comment analyser des chaînes à l’aide de String. Split Contient un exemple de code qui illustre l’utilisation de la méthode String.Split pour analyser des chaînes.
Comment rechercher des chaînes Explique comment rechercher du texte ou des modèles spécifiques dans des chaînes.
Comment déterminer si une chaîne représente une valeur numérique Montre comment analyser une chaîne en toute sécurité pour déterminer si elle possède une valeur numérique valide.
Interpolation de chaîne Décrit la fonctionnalité d’interpolation de chaîne qui fournit une syntaxe pratique pour les chaînes de format.
Opérations de chaînes de base Fournit des liens vers des rubriques utilisant les méthodes System.String et System.Text.StringBuilder pour effectuer des opérations de chaînes de base.
Analyse de chaînes Décrit comment convertir des représentations sous forme de chaîne de types de base .NET en instances de types correspondants.
Analyse des chaînes de date et d’heure dans .NET Montre comment convertir une chaîne telle que « 24/01/2008 » en objet System.DateTime.
Comparaison de chaînes Inclut des informations sur la façon de comparer des chaînes et fournit des exemples en C# et Visual Basic.
Utilisation de la classe StringBuilder Explique comment créer et modifier des objets string dynamiques avec la classe StringBuilder.
LINQ et chaînes Fournit des informations sur l’exécution de différentes opérations sur des chaînes à l’aide de requêtes LINQ.
Guide de programmation C# Fournit des liens vers des rubriques qui expliquent les constructions de programmation en C#.