Chaînes (Guide de programmation C#)Strings (C# Programming Guide)

Une chaîne est un objet de type String dont la valeur est du texte.A string is an object of type String whose value is text. En interne, le texte est stocké sous la forme d’une collection séquentielle en lecture seule d’objets Char.Internally, the text is stored as a sequential read-only collection of Char objects. 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').There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters ('\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.The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. Pour accéder à des points de code Unicode individuels dans une chaîne, utilisez l’objet StringInfo.To access the individual Unicode code points in a string, use the StringInfo object.

Comparatif entre string et System.Stringstring vs. System.String

En C#, le mot clé string est un alias pour String.In C#, the string keyword is an alias for String. Par conséquent, String et string sont équivalents et vous pouvez utiliser la convention d’affectation de noms que vous préférez.Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. La classe String fournit de nombreuses méthodes pour créer, manipuler et comparer des chaînes en toute sécurité.The String class provides many methods for safely creating, manipulating, and comparing strings. En outre, le langage C# surcharge certains opérateurs pour simplifier les opérations de chaînes courantes.In addition, the C# language overloads some operators to simplify common string operations. Pour plus d’informations sur le mot clé, voir chaîne.For more information about the keyword, see string. Pour plus d’informations sur le type et ses méthodes, consultez String.For more information about the type and its methods, see String.

Déclaration et initialisation de chaînesDeclaring and Initializing Strings

Vous pouvez déclarer et initialiser des chaînes de différentes manières, comme illustré dans l’exemple suivant :You can declare and initialize strings in various ways, as shown in the following example:

// 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.Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Initialisez une chaîne avec la valeur constante Empty pour créer un objet String dont la chaîne est de longueur nulle.Initialize a string with the Empty constant value to create a new String object whose string is of zero length. La représentation de littéral de chaîne d’une chaîne de longueur nulle est "".The string literal representation of a zero-length string is "". 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.By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Utilisez la méthode statique IsNullOrEmpty(String) pour vérifier la valeur d’une chaîne avant de tenter d’y accéder.Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Immuabilité des objets StringImmutability of String Objects

Les objets String sont immuables : ils ne peuvent pas être modifiés une fois qu’ils ont été créés.String objects are immutable: they cannot be changed after they have been created. 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.All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. 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.In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. L’opérateur += crée une nouvelle chaîne qui contient le contenu combiné.The += operator creates a new string that contains the combined contents. 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.That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

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.Because a string "modification" is actually a new string creation, you must use caution when you create references to strings. 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.If you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. Le code suivant illustre ce comportement :The following code illustrates this behavior:

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

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

Pour plus d’informations sur la création de nouvelles chaînes basées sur des modifications telles que les opérations rechercher-remplacer sur la chaîne d’origine, voir Guide pratique pour modifier du contenu de chaîne.For more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to: Modify String Contents.

Littéraux de chaînes normales et textuellesRegular and Verbatim String Literals

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 :Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

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.Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. É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.Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Utilisez des guillemets doubles pour incorporer des guillemets dans une chaîne textuelle.Use double quotation marks to embed a quotation mark inside a verbatim string. L’exemple suivant montre certaines utilisations courantes des chaînes textuelles :The following example shows some common uses for verbatim strings:

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îneString Escape Sequences

Séquence d'échappementEscape sequence Nom du caractèreCharacter name Encodage UnicodeUnicode encoding
\'\' Guillemet simpleSingle quote 0x00270x0027
\"\" Guillemet doubleDouble quote 0x00220x0022
\\ Barre oblique inverseBackslash 0x005C0x005C
\0\0 NullNull 0x00000x0000
\a\a AlerteAlert 0x00070x0007
\b\b Retour arrièreBackspace 0x00080x0008
\f\f Saut de pageForm feed 0x000C0x000C
\n\n Nouvelle ligneNew line 0x000A0x000A
\r\r Retour chariotCarriage return 0x000D0x000D
\t\t Tabulation horizontaleHorizontal tab 0x00090x0009
\v\v Tabulation verticaleVertical tab 0x000B0x000B
\u\u Séquence d’échappement Unicode (UTF-16)Unicode escape sequence (UTF-16) \uHHHH (plage : 0000 - FFFF ; exemple : \u00E7 = "ç")\uHHHH (range: 0000 - FFFF; example: \u00E7 = "ç")
\U\U Séquence d’échappement Unicode (UTF-32)Unicode escape sequence (UTF-32) \U00HHHHHH (plage : 000000 - 10FFFF ; exemple : \U0001F47D = "👽")\U00HHHHHH (range: 000000 - 10FFFF; example: \U0001F47D = "👽")
\x\x Séquence d’échappement Unicode similaire à "\u", mais avec une longueur variableUnicode escape sequence similar to "\u" except with variable length \xH[H][H][H] (plage : 0 - FFFF ; exemple : \x00E7 or \x0E7 or \xE7 = "ç")\xH[H][H][H] (range: 0 - FFFF; example: \x00E7 or \x0E7 or \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.When using the \x escape sequence and specifying less than 4 hex digits, if the characters that immediately follow the escape sequence are valid hex digits (i.e. 0-9, A-F, and a-f), they will be interpreted as being part of the escape sequence. Par exemple, \xA1 donne "¡", qui est le point de code U+00A1.For example, \xA1 produces "¡", which is code point 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.However, if the next character is "A" or "a", then the escape sequence will instead be interpreted as being \xA1A and produce "ਚ", which is code point U+0A1A. Dans ce cas, la spécification des 4 chiffres hexadécimaux (par ex. \x00A1) empêche toute mauvaise interprétation possible.In such cases, specifying all 4 hex digits (e.g. \x00A1 ) will prevent any possible misinterpretation.

Notes

Au moment de la compilation, les chaînes textuelles sont converties en chaînes normales avec les mêmes séquences d’échappement.At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. 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.Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. Par exemple, la chaîne textuelle @"C:\files.txt" s’affiche dans la fenêtre Espion en tant que "C:\\files.txt".For example, the verbatim string @"C:\files.txt" will appear in the watch window as "C:\\files.txt".

Chaînes de formatFormat Strings

Une chaîne de format est une chaîne dont le contenu est déterminé de façon dynamique lors de l’exécution.A format string is a string whose contents are determined dynamically at runtime. 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.Format strings are created by embedding interpolated expressions or placeholders inside of braces within a string. 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.Everything inside the braces ({...}) will be resolved to a value and output as a formatted string at runtime. Il existe deux méthodes pour créer des chaînes de format : l’interpolation de chaîne et la mise en forme composite.There are two methods to create format strings: string interpolation and composite formatting.

Interpolation de chaîneString Interpolation

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.Available in C# 6.0 and later, interpolated strings are identified by the $ special character and include interpolated expressions in braces. 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.If you are new to string interpolation, see the String interpolation - C# interactive tutorial for a quick overview.

Utilisez l’interpolation de chaîne pour améliorer la lisibilité et la maintenance de votre code.Use string interpolation to improve the readability and maintainability of your 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é.String interpolation achieves the same results as the String.Format method, but improves ease of use and inline clarity.

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. 

Mise en forme compositeComposite Formatting

String.Format utilise des espaces réservés entre accolades pour créer une chaîne de format.The String.Format utilizes placeholders in braces to create a format string. Cet exemple renvoie une sortie similaire à la méthode d’interpolation de chaîne utilisée ci-dessus.This example results in similar output to the string interpolation method used above.

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.For more information on formatting .NET types see Formatting Types in .NET.

Sous-chaînesSubstrings

Une sous-chaîne est une séquence de caractères qui est contenue dans une chaîne.A substring is any sequence of characters that is contained in a string. Utilisez la méthode Substring pour créer une chaîne à partir d’une partie de la chaîne d’origine.Use the Substring method to create a new string from a part of the original string. Vous pouvez rechercher une ou plusieurs occurrences d’une sous-chaîne en utilisant la méthode IndexOf.You can search for one or more occurrences of a substring by using the IndexOf method. Utilisez la méthode Replace pour remplacer toutes les occurrences d’une sous-chaîne spécifiée par une nouvelle chaîne.Use the Replace method to replace all occurrences of a specified substring with a new string. Comme la méthode Substring, Replace retourne en fait une nouvelle chaîne et ne modifie pas la chaîne d’origine.Like the Substring method, Replace actually returns a new string and does not modify the original string. Pour plus d’informations, consultez Guide pratique pour rechercher des chaînes et Guide pratique pour modifier le contenu des chaînes.For more information, see How to: search strings and How to: Modify String Contents.

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 individuelsAccessing Individual Characters

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 :You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

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.If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars "in-place", and then create a new string to store the results by using the StringBuilder methods. 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 :In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

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 videsNull Strings and Empty Strings

Une chaîne vide est une instance d’un objet System.String qui contient zéro caractère.An empty string is an instance of a System.String object that contains zero characters. Les chaînes vides sont souvent utilisées dans divers scénarios de programmation pour représenter un champ de texte vide.Empty strings are used often in various programming scenarios to represent a blank text field. Vous pouvez appeler des méthodes sur des chaînes vides, car ce sont des objets System.String.You can call methods on empty strings because they are valid System.String objects. Les chaînes vides sont initialisées comme suit :Empty strings are initialized as follows:

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.By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. Toutefois, vous pouvez utiliser des chaînes Null dans les opérations de comparaison et de concaténation avec d’autres chaînes.However, you can use null strings in concatenation and comparison operations with other strings. 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 :The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

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îneUsing StringBuilder for Fast String Creation

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.String operations in .NET are highly optimized and in most cases do not significantly impact performance. 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.However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. 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.The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. 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.The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. Ce code, par exemple, modifie le contenu d’une chaîne sans créer de nouvelle chaîne :This code, for example, changes the content of a string without creating a new string:

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 :In this example, a StringBuilder object is used to create a string from a set of numeric types:

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 LINQStrings, Extension Methods and 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.Because the String type implements IEnumerable<T>, you can use the extension methods defined in the Enumerable class on strings. Pour éviter une surcharge visuelle, ces méthodes sont exclues d’IntelliSense pour le type String, mais elles restent néanmoins disponibles.To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. Vous pouvez également utiliser des expressions de requête LINQLINQ sur les chaînes.You can also use LINQLINQ query expressions on strings. Pour plus d’informations, consultez LINQ et Strings.For more information, see LINQ and Strings.

RubriqueTopic DescriptionDescription
Guide pratique pour modifier le contenu des chaînesHow to: Modify String Contents Illustre les techniques permettant de transformer des chaînes et de modifier le contenu de chaînes.Illustrates techniques to transform strings and modify the contents of strings.
Guide pratique pour comparer des chaînesHow to: Compare Strings Montre comment effectuer des comparaisons de chaînes ordinales et spécifiques à la culture.Shows how to perform ordinal and culture specific comparisons of strings.
Guide pratique pour concaténer plusieurs chaînesHow to: Concatenate Multiple Strings Illustre différentes manières de joindre plusieurs chaînes pour en former une.Demonstrates various ways to join multiple strings into one.
Guide pratique pour analyser des chaînes à l’aide de String.SplitHow to: Parse Strings Using String.Split Contient un exemple de code qui illustre l’utilisation de la méthode String.Split pour analyser des chaînes.Contains code examples that illustrate how to use the String.Split method to parse strings.
Guide pratique pour rechercher des chaînesHow to: Search Strings Explique comment rechercher du texte ou des modèles spécifiques dans des chaînes.Explains how to use search for specific text or patterns in strings.
Guide pratique pour déterminer si une chaîne représente une valeur numériqueHow to: Determine Whether a String Represents a Numeric Value Montre comment analyser une chaîne en toute sécurité pour déterminer si elle possède une valeur numérique valide.Shows how to safely parse a string to see whether it has a valid numeric value.
Interpolation de chaîneString interpolation Décrit la fonctionnalité d’interpolation de chaîne qui fournit une syntaxe pratique pour les chaînes de format.Describes the string interpolation feature that provides a convenient syntax to format strings.
Opérations de chaînes de baseBasic String Operations 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.Provides links to topics that use System.String and System.Text.StringBuilder methods to perform basic string operations.
Parsing StringsParsing Strings Décrit comment convertir des représentations sous forme de chaîne de types de base .NET en instances de types correspondants.Describes how to convert string representations of .NET base types to instances of the corresponding types.
Analyse des chaînes de date et d’heure dans .NETParsing Date and Time Strings in .NET Montre comment convertir une chaîne telle que « 24/01/2008 » en objet System.DateTime.Shows how to convert a string such as "01/24/2008" to a System.DateTime object.
Comparaison de chaînesComparing Strings Inclut des informations sur la façon de comparer des chaînes et fournit des exemples en C# et Visual Basic.Includes information about how to compare strings and provides examples in C# and Visual Basic.
Utilisation de la classe StringBuilderUsing the StringBuilder Class Explique comment créer et modifier des objets string dynamiques avec la classe StringBuilder.Describes how to create and modify dynamic string objects by using the StringBuilder class.
LINQ et chaînesLINQ and Strings Fournit des informations sur l’exécution de différentes opérations sur des chaînes à l’aide de requêtes LINQ.Provides information about how to perform various string operations by using LINQ queries.
Guide de programmation C#C# Programming Guide Fournit des liens vers des rubriques qui expliquent les constructions de programmation en C#.Provides links to topics that explain programming constructs in C#.