String String String String Class

Définition

Représente le texte en tant que séquence d’unités de code UTF-16.Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Héritage
StringStringStringString
Attributs
Implémente

Remarques

Une chaîne est une collection séquentielle de caractères utilisée pour représenter du texte.A string is a sequential collection of characters that is used to represent text. Un String objet est une collection séquentielle d' System.Char objets qui représentent une chaîne; un System.Char objet correspond à une unité de code UTF-16.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. La valeur de l' String objet est le contenu de la collection d' System.Char objets séquentielle, et cette valeur est immuable (autrement dit, elle est en lecture seule).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Pour plus d’informations sur l’immuabilité des chaînes, consultez la section immuabilité et la classe StringBuilder plus loin dans cette rubrique.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. La taille maximale d’un String objet en mémoire est de 2 Go, soit environ 1 milliard caractères.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Sélectionnez le bouton Exécuter s’il apparaît pour exécuter un exemple dans une fenêtre interactive.When present, select the Run button to run an example in an interactive window. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter.Once you execute the code, you can modify it and run the modified code by selecting Run again. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Dans cette section :In this section:

Instanciation d’un objet String Instantiating a String object
Objets Char et caractères Unicode Char objects and Unicode characters
Chaînes et la norme Unicode Strings and The Unicode Standard
Chaînes et caractères null incorporés Strings and embedded null characters
Chaînes et index Strings and indexes
Chaînes NULL et chaînes vides Null strings and empty strings
Immuabilité et la classe StringBuilder Immutability and the StringBuilder class
Opérations ordinales et dépendantes de la culture Ordinal vs. culture-sensitive operations
Normalisation Normalization
Opérations de chaîne par catégorieString operations by category

Instanciation d’un objet StringInstantiating a String object

Vous pouvez instancier String un objet des manières suivantes:You can instantiate a String object in the following ways:

  • En assignant un littéral de chaîne String à une variable.By assigning a string literal to a String variable. Il s’agit de la méthode la plus couramment utilisée pour créer une chaîne.This is the most commonly used method for creating a string. L’exemple suivant utilise l’assignation pour créer plusieurs chaînes.The following example uses assignment to create several strings. Notez que dans C#, étant donné que la\barre oblique inverse () est un caractère d’échappement, les barres obliques inverses littérales dans une chaîne @-quoteddoivent être placées dans une séquence d’échappement ou la chaîne entière doit être.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • En appelant un String constructeur de classe.By calling a String class constructor. L’exemple suivant instancie des chaînes en appelant plusieurs constructeurs de classe.The following example instantiates strings by calling several class constructors. Notez que certains des constructeurs incluent des pointeurs vers des tableaux de caractères ou des tableaux d’octets signés en tant que paramètres.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic ne prend pas en charge les appels à ces constructeurs.Visual Basic does not support calls to these constructors. Pour plus d’informations String sur les constructeurs, consultez String le résumé du constructeur.For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • En utilisant l’opérateur de concaténation de chaînes ( C# + in et & ou + dans Visual Basic) pour créer une chaîne unique à partir String de n’importe quelle combinaison d’instances et de littéraux de chaîne.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. L’exemple suivant illustre l’utilisation de l’opérateur de concaténation de chaînes.The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • En extrayant une propriété ou en appelant une méthode qui retourne une chaîne.By retrieving a property or calling a method that returns a string. L’exemple suivant utilise les méthodes de la String classe pour extraire une sous-chaîne d’une chaîne plus grande.The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • En appelant une méthode de mise en forme pour convertir une valeur ou un objet en sa représentation sous forme de chaîne.By calling a formatting method to convert a value or object to its string representation. L’exemple suivant utilise la fonctionnalité de mise en forme composite pour incorporer la représentation sous forme de chaîne de deux objets dans une chaîne.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    

Objets Char et caractères UnicodeChar objects and Unicode characters

Chaque caractère d’une chaîne est défini par une valeur scalaire Unicode, également appelée point de code Unicode ou la valeur ordinale (numérique) du caractère Unicode.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Chaque point de code est encodé à l’aide de l’encodage UTF-16, et la valeur numérique de chaque élément de l’encodage Char est représentée par un objet.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Notes

Notez que, étant donné String qu’une instance se compose d’une collection séquentielle d’unités de code UTF-16, il est String possible de créer un objet qui n’est pas une chaîne Unicode bien formée.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Par exemple, il est possible de créer une chaîne qui a un substitut faible sans un substitut étendu correspondant.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Bien que certaines méthodes, telles que les méthodes d’encodage et de décodage System.Text des objets dans l’espace de noms, puissent effectuer des vérifications pour s' String assurer que les chaînes sont bien formées, les membres de classe ne garantissent pas qu’une chaîne est correctement formée.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Un seul Char objet représente généralement un point Char de code unique; autrement dit, la valeur numérique de est égale au point de code.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Par exemple, le point de code du caractère «a» est U + 0061.For example, the code point for the character "a" is U+0061. Toutefois, un point de code peut nécessiter plus d’un élément encodé (plus d’un Char objet).However, a code point might require more than one encoded element (more than one Char object). La norme Unicode définit deux types de caractères qui correspondent à plusieurs Char objets: graphemes et les points de code supplémentaires Unicode qui correspondent aux caractères dans les plans Unicode supplémentaires.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Un graphèmes est représenté par un caractère de base suivi d’un ou de plusieurs caractères d’association.A grapheme is represented by a base character followed by one or more combining characters. Par exemple, le caractère ä est représenté par un Char objet dont le point de code est u + 0061 suivi Char d’un objet dont le point de code est u + 0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Ce caractère peut également être défini par un objet Char unique qui a un point de code de U + 00E4.This character can also be defined by a single Char object that has a code point of U+00E4. Comme le montre l’exemple suivant, une comparaison dépendante de la culture pour l’égalité indique que ces deux représentations sont égales, bien qu’une comparaison ordinale ordinaire ne le fasse pas.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Toutefois, si les deux chaînes sont normalisées, une comparaison ordinale indique également qu’elles sont égales.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Pour plus d’informations sur la normalisation des chaînes, consultez la section normalisation .)(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Un point de code supplémentaire Unicode (une paire de substitution) est représenté Char par un objet dont le point de code est un substitut Char étendu suivi d’un objet dont le point de code est un caractère de substitution faible.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Les unités de code des substituts étendus sont comprises entre U + D800 et U + DBFF.The code units of high surrogates range from U+D800 to U+DBFF. Les unités de code des substituts faibles sont comprises entre U + DC00 et et U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Les paires de substitution sont utilisées pour représenter des caractères dans les 16 plans supplémentaires Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. L’exemple suivant crée un caractère de substitution et le passe à Char.IsSurrogatePair(Char, Char) la méthode pour déterminer s’il s’agit d’une paire de substitution.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

Chaînes et la norme UnicodeStrings and the Unicode Standard

Les caractères d’une chaîne sont représentés par des unités de code encodées en UTF-16 Char , qui correspondent aux valeurs.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Chaque caractère d’une chaîne est associé à une catégorie de caractères Unicode, qui est représentée dans .NET UnicodeCategory par l’énumération.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. La catégorie d’un caractère ou d’une paire de substitution peut être déterminée en CharUnicodeInfo.GetUnicodeCategory appelant la méthode.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET gère sa propre table de caractères et ses catégories correspondantes, ce qui garantit qu’une version spécifique d’une implémentation de .NET s’exécutant sur différentes plateformes retourne des informations de catégorie de caractère identiques..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Sur .NET Core exécuté sur Linux et macOS, les informations de catégorie de caractère sont fournies par les bibliothèques International Components for Unicode.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

Le tableau suivant liste les versions de .NET et les versions de la norme Unicode Standard sur lesquelles reposent leurs catégories de caractère.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Version de .NET.NET version Version de la norme Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 The Unicode Standard, version 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 et versions ultérieures.NET Framework 4.6.2 and later versions The Unicode Standard, version 8.0.0The Unicode Standard, Version 8.0.0
.NET Core (toutes les versions).NET Core (all versions) The Unicode Standard, version 8.0.0The Unicode Standard, Version 8.0.0

En outre, .NET prend en charge la comparaison et le tri des chaînes en fonction de la norme Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. Dans les versions du .NET Framework par le .NET Framework 4.NET Framework 4biais de, le .NET Framework gérer sa propre table de données de type chaîne.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Cela est également vrai pour les versions du .NET Framework qui commencent par .NET Framework 4.5.NET Framework 4.5 le s’exécutant sur Windows 7.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. En commençant par .NET Framework 4.5.NET Framework 4.5 le s’exécutant sur Windows 8 et les versions ultérieures du système d’exploitation Windows, le runtime délègue les opérations de comparaison et de tri de chaînes au système d’exploitation.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. Sur .NET Core, les informations de comparaison et de tri de chaînes sont fournies par les composants internationaux pour les bibliothèques Unicode . Le tableau suivant répertorie les versions de .NET et les versions de la norme Unicode sur lesquelles les comparaisons de caractères et le tri sont basés.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Version de .NET.NET version Version de la norme Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 The Unicode Standard, version 4.0.0The Unicode Standard, Version 4.0.0
Le .NET Framework 2,0The .NET Framework 2.0 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5et versions ultérieures sur Windows 7and later on Windows 7 The Unicode Standard, version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5et versions ultérieures sur les systèmes d’exploitation Windows 8 et versions ultérieuresand later on Windows 8 and later Windows operating systems The Unicode Standard, version 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (toutes les versions).NET Core (all versions) En fonction de la version de la norme Unicode prise en charge par le système d’exploitation sous-jacent.Depends on the version of the Unicode Standard supported by the underlying operating system.

Chaînes et caractères null incorporésStrings and embedded null characters

Dans .net, un String objet peut inclure des caractères null incorporés, qui comptent comme une partie de la longueur de la chaîne.In .NET, a String object can include embedded null characters, which count as a part of the string's length. Toutefois, dans certains langages tels que C C++et, un caractère null indique la fin d’une chaîne; elle n’est pas considérée comme faisant partie de la chaîne et n’est pas comptabilisée comme faisant partie de la longueur de la chaîne.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Cela signifie que les hypothèses courantes suivantes que c, C++ les programmeurs ou les bibliothèques écrites en C++ c ou peuvent faire sur des chaînes ne sont pas nécessairement String valides lorsqu’elles sont appliquées aux objets:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • La valeur retournée par strlen les wcslen fonctions ou n’est pas String.Lengthnécessairement égale à.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • La chaîne créée par les strcpy_s fonctions wcscpy_s ou n’est pas nécessairement identique à la chaîne créée par String.Copy la méthode.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Vous devez vous assurer que le code C++ natif C et le String code qui instancie les objets, String ainsi que le code qui reçoit des objets via l’appel de code non managé, ne supposent pas qu’un caractère null incorporé marque la fin de la chaîne.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

Les caractères null incorporés dans une chaîne sont également traités différemment lorsqu’une chaîne est triée (ou comparée) et lors de la recherche d’une chaîne.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Les caractères Null sont ignorés lors de l’exécution de comparaisons dépendantes de la culture entre deux chaînes, y compris les comparaisons qui utilisent la culture dite indifférente.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Ils sont considérés uniquement pour les comparaisons ordinales ou non sensibles à la casse.They are considered only for ordinal or case-insensitive ordinal comparisons. En revanche, les caractères null incorporés sont toujours pris en compte lors de la recherche d’une Containschaîne StartsWithavec des IndexOfméthodes telles que, et.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Chaînes et indexStrings and indexes

Un index est la position d’un Char objet (pas un caractère Unicode) dans un String.An index is the position of a Char object (not a Unicode character) in a String. Un index est un nombre non négatif de base zéro qui démarre à partir de la première position dans la chaîne, qui est la position d’index zéro.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Plusieurs méthodes de recherche, telles que IndexOf et LastIndexOf, retournent l’index d’un caractère ou d’une sous-chaîne dans l’instance de chaîne.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

La Chars[Range] propriété vous permet d’accéder Char à des objets individuels en fonction de leur position d’index dans la chaîne.The Chars[Range] property lets you access individual Char objects by their index position in the string. Étant donné Chars[Range] que la propriété est la propriété par défaut (dans Visual Basic) ou l’indexeur (en C#), vous pouvez Char accéder aux objets individuels dans une chaîne à l’aide d’un code tel que le suivant.Because the Chars[Range] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Ce code recherche des espaces blancs ou des caractères de ponctuation dans une chaîne pour déterminer le nombre de mots que la chaîne contient.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Étant donné String que la classe implémente l' IEnumerable interface, vous Char pouvez également itérer au sein des objets d’une chaîne foreach à l’aide d’une construction, comme le montre l’exemple suivant.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Les valeurs d’index consécutives peuvent ne pas correspondre à des caractères Unicode consécutifs, car un caractère Unicode peut être encodé Char sous la forme de plusieurs objets.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. En particulier, une chaîne peut contenir des unités de texte à plusieurs caractères qui sont formées par un caractère de base suivi d’un ou de plusieurs caractères d’association ou par paires de substitution.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Pour travailler avec des caractères Unicode à Char la place d’objets System.Globalization.StringInfo , TextElementEnumerator utilisez les classes et.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. L’exemple suivant illustre la différence entre le code qui fonctionne avec Char les objets et le code qui fonctionne avec les caractères Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Il compare le nombre de caractères ou d’éléments de texte dans chaque mot d’une phrase.It compares the number of characters or text elements in each word of a sentence. La chaîne comprend deux séquences d’un caractère de base suivies d’un caractère d’association.The string includes two sequences of a base character followed by a combining character.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

foreach (var ch in opening) {
   // Skip the ' character.
   if (ch == '\u0027') continue;
        
   if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
      chars.Add(nChars);
      nChars = 0;
   }
   else {
      nChars++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.StringInfo.GetTextElementEnumerator(opening);
while (te.MoveNext()) {
   string s = te.GetTextElement();   
   // Skip the ' character.
   if (s == "\u0027") continue;
   if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
      elements.Add(nChars);         
      nChars = 0;
   }
   else {
      nChars++;
   }
}

// Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
                  "Word #", "Char Objects", "Characters"); 
for (int ctr = 0; ctr < chars.Count; ctr++) 
   Console.WriteLine("{0,6} {1,20} {2,20}",
                     ctr, chars[ctr], elements[ctr]); 
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

Cet exemple fonctionne avec les éléments de texte à StringInfo.GetTextElementEnumerator l’aide de TextElementEnumerator la méthode et de la classe pour énumérer tous les éléments de texte d’une chaîne.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. Vous pouvez également récupérer un tableau qui contient l’index de départ de chaque élément de texte en StringInfo.ParseCombiningCharacters appelant la méthode.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Pour plus d’informations sur l’utilisation des unités de texte plutôt Char que des valeurs individuelles StringInfo , consultez la classe.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Chaînes NULL et chaînes videsNull strings and empty strings

Une chaîne qui a été déclarée mais dont la valeur n’a pas nullété assignée est.A string that has been declared but has not been assigned a value is null. Toute tentative d’appel de méthodes sur cette chaîne lève NullReferenceExceptionune.Attempting to call methods on that string throws a NullReferenceException. Une chaîne NULL est différente d’une chaîne vide, qui est une chaîne dont la valeur est «» String.Emptyou.A null string is different from an empty string, which is a string whose value is "" or String.Empty. Dans certains cas, le passage d’une chaîne null ou d’une chaîne vide en tant qu’argument dans un appel de méthode lève une exception.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Par exemple, le passage d’une chaîne null Int32.Parse à la méthode lève ArgumentNullExceptionune exception et le passage d’une chaîne vide FormatExceptionlève une.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. Dans d’autres cas, un argument de méthode peut être soit une chaîne nulle, soit une chaîne vide.In other cases, a method argument can be either a null string or an empty string. Par exemple, si vous fournissez une IFormattable implémentation pour une classe, vous souhaitez faire correspondre à la fois une chaîne NULL et une chaîne vide avec le spécificateur de format général («G»).For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

La String classe comprend les deux méthodes pratiques suivantes qui vous permettent de tester si une chaîne est null ou vide:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, qui indique si une chaîne est null ou est égal à. String.EmptyIsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Cette méthode élimine la nécessité d’utiliser un code tel que le suivant:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, qui indique si une chaîne est null, est String.Emptyégal à, ou se compose exclusivement d’espaces blancs.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Cette méthode élimine la nécessité d’utiliser un code tel que le suivant:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

L’exemple suivant utilise la IsNullOrEmpty méthode dans l' IFormattable.ToString implémentation d’une classe Temperature personnalisée.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. La méthode prend en charge les chaînes de format "G", "C", "F" et "K".The method supports the "G", "C", "F", and "K" format strings. Si une chaîne de format vide ou une chaîne de format dont null la valeur est est passée à la méthode, sa valeur est remplacée par la chaîne de format "G".If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

Immuabilité et la classe StringBuilderImmutability and the StringBuilder class

Un String objet est appelé immuable (en lecture seule), car sa valeur ne peut pas être modifiée une fois qu’il a été créé.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Les méthodes qui semblent modifier un String objet retournent en String fait un nouvel objet qui contient la modification.Methods that appear to modify a String object actually return a new String object that contains the modification.

Étant donné que les chaînes sont immuables, les routines de manipulation de chaînes qui effectuent des ajouts ou des suppressions répétés à ce qui semble être une chaîne unique peuvent avoir une incidence significative sur les performances.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Par exemple, le code suivant utilise un générateur de nombres aléatoires pour créer une chaîne de 1000 caractères dans la plage 0x0001 à 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Bien que le code semble utiliser la concaténation de chaînes pour ajouter un nouveau caractère à la chaîne strexistante nommée, il crée en String fait un nouvel objet pour chaque opération de concaténation.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

Vous pouvez utiliser la StringBuilder classe au lieu de String la classe pour les opérations qui apportent plusieurs modifications à la valeur d’une chaîne.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Contrairement aux instances de String la classe StringBuilder , les objets sont mutables; quand vous concaténez, ajoutez ou supprimez des sous-chaînes à partir d’une chaîne, les opérations sont exécutées sur une chaîne unique.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Lorsque vous avez terminé de modifier la valeur d’un StringBuilder objet, vous pouvez appeler sa StringBuilder.ToString méthode pour la convertir en chaîne.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. L’exemple suivant remplace le String utilisé dans l’exemple précédent pour concaténer 1000 caractères aléatoires de la plage en 0x0001 en 0x052F avec StringBuilder un objet.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

Opérations ordinales et dépendantes de la cultureOrdinal vs. culture-sensitive operations

Les membres de String la classe effectuent des opérations ordinales ou dépendantes de la String culture (linguistiques) sur un objet.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Une opération ordinale agit sur la valeur numérique de Char chaque objet.An ordinal operation acts on the numeric value of each Char object. Une opération dépendante de la culture agit sur la String valeur de l’objet et prend en compte la casse, le tri, la mise en forme et les règles d’analyse spécifiques à la culture.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Les opérations dépendantes de la culture s’exécutent dans le contexte d’une culture explicitement déclarée ou de la culture actuelle implicite.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Les deux types d’opérations peuvent produire des résultats très différents lorsqu’ils sont exécutés sur la même chaîne.The two kinds of operations can produce very different results when they are performed on the same string.

.NET prend également en charge les opérations de chaînes linguistiques indépendantes de la culture à l’aideCultureInfo.InvariantCulturede la culture dite indifférente (), qui est faible en fonction des paramètres de culture de la langue anglaise indépendante de la région..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. Contrairement à System.Globalization.CultureInfo d’autres paramètres, les paramètres de la culture dite indifférente sont garantis pour rester cohérents sur un seul ordinateur, du système au système et dans les versions de .net.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. La culture dite indifférente peut être considérée comme un type de boîte noire qui garantit la stabilité des comparaisons de chaînes et le classement dans toutes les cultures.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Important

Si votre application prend une décision de sécurité sur un identificateur symbolique, tel qu’un nom de fichier ou un canal nommé, ou à propos de données persistantes telles que les données textuelles dans un fichier XML, l’opération doit utiliser une comparaison ordinale au lieu d’une comparaison dépendante de la culture.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Cela est dû au fait qu’une comparaison dépendante de la culture peut produire des résultats différents selon la culture en vigueur, alors qu’une comparaison ordinale dépend uniquement de la valeur binaire des caractères comparés.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Important

La plupart des méthodes qui effectuent des opérations de chaînes incluent une surcharge qui StringComparisona un paramètre de type, ce qui vous permet de spécifier si la méthode effectue une opération ordinale ou dépendante de la culture.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. En général, vous devez appeler cette surcharge pour que l’objectif de votre appel de méthode soit clair.In general, you should call this overload to make the intent of your method call clear. Pour obtenir les meilleures pratiques et des conseils sur l’utilisation des opérations ordinales et dépendantes de la culture sur les chaînes, consultez meilleures pratiques pour l’utilisation de chaînes.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Les opérations de casse, d' analyse et de mise en forme, de comparaison et de triet de test de l’égalité peuvent être ordinales ou dépendantes de la culture.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. Les sections suivantes décrivent chaque catégorie d’opération.The following sections discuss each category of operation.

Conseil

Vous devez toujours appeler une surcharge de méthode qui rend l’objectif de votre appel de méthode clair.You should always call a method overload that makes the intent of your method call clear. Par exemple, au lieu d’appeler Compare(String, String) la méthode pour effectuer une comparaison dépendante de la culture de deux chaînes en utilisant les conventions de la culture actuelle, Compare(String, String, StringComparison) vous devez appeler la StringComparison.CurrentCulture méthode avec une comparisonType valeur pour l’objet argument.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Pour plus d’informations, consultez Bonnes pratiques l’utilisation de chaînes.For more information, see Best Practices for Using Strings.

Vous pouvez télécharger les Sorting Weight Tables, un ensemble de fichiers texte qui contiennent des informations sur les poids des caractères utilisés dans les opérations de tri et de comparaison pour les systèmes d’exploitation Windows et la Default Unicode Collation Element Table, la table de pondération de tri pour Linux et macOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

RapportCasing

Les règles de casse déterminent comment modifier la mise en majuscules d’un caractère Unicode. par exemple, de minuscules à majuscules.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Souvent, une opération de casse est effectuée avant une comparaison de chaînes.Often, a casing operation is performed before a string comparison. Par exemple, une chaîne peut être convertie en majuscules pour pouvoir être comparée à une autre chaîne en majuscules.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Vous pouvez convertir les caractères d’une chaîne en minuscules en appelant ToLower la ToLowerInvariant méthode ou, et vous pouvez les convertir en majuscules en ToUpper appelant ToUpperInvariant la méthode ou.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. En outre, vous pouvez utiliser la TextInfo.ToTitleCase méthode pour convertir une chaîne en majuscules.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Notes

.NET Core s’exécutant sur les systèmes Linux et macOS uniquement : Le comportement de classement pour les cultures C et Posix respecte toujours la casse, car ces cultures n’utilisent pas l’ordre de classement Unicode attendu..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Nous vous recommandons d’utiliser une culture autre que C ou Posix pour effectuer des opérations de tri respectant la culture, mais ne respectant pas la casse.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Les opérations de casse peuvent être basées sur les règles de la culture actuelle, une culture spécifiée ou la culture dite indifférente.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Étant donné que les mappages de cas peuvent varier en fonction de la culture utilisée, le résultat des opérations de casse peut varier en fonction de la culture.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Les différences réelles de la casse sont de trois types:The actual differences in casing are of three kinds:

  • Différences dans le mappage de casse de la lettre majuscule latine I (U + 0049), lettre minuscule latine I (U + 0069), lettre majuscule latine I avec point ci-dessus (U + 0130) et lettre minuscule latine I sans point (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). Dans les cultures tr-TR (turc (Turquie)) et az-Latn-AZ (Azerbaïdjan, latin), et dans les cultures de la TR, AZ et az-Latn neutral, l’équivalent en minuscules de la lettre majuscule latine i est la lettre minuscule latine i sans point et l’équivalent en majuscule de la lettre minuscule latine I est LETTRE MAJUSCULE LATINE I AVEC POINT CI-DESSUS.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. Dans toutes les autres cultures, y compris la culture dite indifférente, la lettre minuscule latine I et la lettre majuscule latine I sont des équivalents en minuscules et en majuscules.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    L’exemple suivant montre comment une comparaison de chaînes conçue pour empêcher l’accès au système de fichiers peut échouer si elle s’appuie sur une comparaison de casse dépendante de la culture.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (Les conventions de casse de la culture dite indifférente doivent avoir été utilisées.)(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Différences de mappage de casse entre la culture dite indifférente et toutes les autres cultures.Differences in case mappings between the invariant culture and all other cultures. Dans ces cas, l’utilisation des règles de casse de la culture dite indifférente pour transformer un caractère en majuscules ou minuscules retourne le même caractère.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Pour toutes les autres cultures, elle retourne un caractère différent.For all other cultures, it returns a different character. Certains des caractères affectés sont répertoriés dans le tableau suivant.Some of the affected characters are listed in the following table.

    CaractèreCharacter En cas de modification enIf changed to Returns (Retours)Returns
    SIGNE MICRON (U + 00B5)MICRON SIGN (U+00B5) MajusculesUppercase LETTRE MAJUSCULE GRECQUE MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    LETTRE MAJUSCULE LATINE I AVEC POINT CI-DESSUS (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) MinusculesLowercase LETTRE MINUSCULE LATINE I (U + 0069)LATIN SMALL LETTER I (U+0069)
    LETTRE MINUSCULE LATINE I SANS POINT (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) MajusculesUppercase LETTRE MAJUSCULE LATINE I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    LETTRE MINUSCULE LATINE S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) MajusculesUppercase LETTRE MAJUSCULE LATINE S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    LETTRE MAJUSCULE LATINE D AVEC PETITE LETTRE Z AVEC CARON (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) MinusculesLowercase LETTRE MINUSCULE LATINE DZ AVEC CARON (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    DIACRITIQUE GREC IOTA SOUSCRIT (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) MajusculesUppercase LETTRE MAJUSCULE GRECQUE IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Différences de mappage de casse des paires casse mixte à deux lettres dans la plage de caractères ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. Dans la plupart des cultures, une paire de casse mixte à deux lettres est égale à la paire en majuscules ou minuscules à deux lettres équivalente.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Cela n’est pas vrai pour les paires à deux lettres suivantes dans les cultures suivantes, car, dans chaque cas, elles sont comparées à un digramme:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • «lJ» et «nJ» dans la culture HR-HR (croate (Croatie))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • «cH» dans les cultures CS-CZ (tchèque (République tchèque)) et SK-SK (slovaque (Slovaquie))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • «aA» dans la culture da-DK (danois (Danemark))."aA" in the da-DK (Danish (Denmark)) culture.

    • «cS», «dZ», «dZS», «nY», «sZ», «tY» et «zS» dans la culture HU-HU (hongrois (Hongrie))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • «cH» et «lL» dans la culture es-ES_tradnl (espagnol (Espagne, traditionnel))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • «cH», «gI», «kH», «nG», «nH», «pH», «qU», «tH» et «tR» dans la culture vi-VN (vietnamien (Vietnam))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    Toutefois, il est rare de rencontrer une situation dans laquelle une comparaison dépendante de la culture de ces paires crée des problèmes, car ces paires ne sont pas courantes dans des chaînes ou des identificateurs fixes.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

L’exemple suivant illustre certaines des différences entre les règles de casse entre les cultures lors de la conversion de chaînes en majuscules.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
     
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

Analyse et mise en formeParsing and formatting

La mise en forme et l’analyse sont des opérations inverses.Formatting and parsing are inverse operations. Les règles de mise en forme déterminent comment convertir une valeur, telle qu’une date et une heure ou un nombre, en représentation sous forme de chaîne, tandis que les règles d’analyse déterminent comment convertir une représentation sous forme de chaîne en une valeur telle qu’une date et une heure.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Les règles de mise en forme et d’analyse dépendent des conventions culturelles.Both formatting and parsing rules are dependent on cultural conventions. L’exemple suivant illustre l’ambiguïté qui peut se produire lors de l’interprétation d’une chaîne de date spécifique à la culture.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Sans connaître les conventions de la culture utilisée pour produire une chaîne de date, il n’est pas possible de savoir si 03/01/2011, 3/1/2011 et 01/03/2011 représentent le 3 janvier 2011 ou le 1er mars 2011.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

De même, comme le montre l’exemple suivant, une chaîne unique peut produire des dates différentes selon la culture dont les conventions sont utilisées dans l’opération d’analyse.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

Comparaison et tri de chaînesString comparison and sorting

Les conventions de comparaison et de tri des chaînes varient d’une culture à l’autres.Conventions for comparing and sorting strings vary from culture to culture. Par exemple, l’ordre de tri peut être basé sur des phonétiques ou sur la représentation visuelle des caractères.For example, the sort order may be based on phonetics or on the visual representation of characters. Dans les langues d'Asie orientale, les caractères sont classés en fonction du trait et de la clé des idéogrammes.In East Asian languages, characters are sorted by the stroke and radical of ideographs. Le tri peut aussi varier en fonction de l'ordre fondamental utilisé par la langue ou la culture pour l'alphabet.Sorting also depends on the order languages and cultures use for the alphabet. Par exemple, la langue danoise emploie un caractère "Æ" qu'elle place après "Z" dans l'alphabet.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. En outre, les comparaisons peuvent respecter la casse ou ne pas respecter la casse, et, dans certains cas, les règles de casse diffèrent également par la culture.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. La comparaison ordinale, en revanche, utilise les points de code Unicode des caractères individuels dans une chaîne lors de la comparaison et du tri des chaînes.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Les règles de tri déterminent l’ordre alphabétique des caractères Unicode et la comparaison entre deux chaînes.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Par exemple, la String.Compare(String, String, StringComparison) méthode compare deux chaînes en fonction du StringComparison paramètre.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Si la valeur du paramètre StringComparison.CurrentCultureest, la méthode effectue une comparaison linguistique qui utilise les conventions de la culture actuelle; si la valeur du StringComparison.Ordinalparamètre est, la méthode effectue une comparaison ordinale.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Par conséquent, comme le montre l’exemple suivant, si la culture actuelle est U.S. L’anglais, le premier appel à String.Compare(String, String, StringComparison) la méthode (à l’aide de la comparaison dépendante de la culture) considère «a» inférieur à «a», mais le deuxième appel à la même méthode (à l’aide de la comparaison ordinale) considère «a» supérieur à «a».Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET prend en charge les règles de tri par mot, chaîne et ordinal:.NET supports word, string, and ordinal sort rules:

  • Un tri par mot effectue une comparaison dépendante de la culture des chaînes dans lesquelles certains caractères Unicode non alphanumériques peuvent avoir des pondérations spéciales qui leur sont affectées.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Par exemple, le trait d’Union (-) peut avoir un très petit poids affecté, de sorte que «Coop» et «co-op» s’affichent à côté les uns des autres dans une liste triée.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Pour obtenir la String liste des méthodes qui comparent deux chaînes à l’aide de règles de tri Word, consultez la section opérations de chaîne par catégorie .For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Un tri de chaîne effectue également une comparaison dépendante de la culture.A string sort also performs a culture-sensitive comparison. Elle est similaire à un tri alphabétique, à ceci près qu’il n’y a aucun cas particulier, et que tous les symboles non alphanumériques sont placés avant tous les caractères Unicode alphanumériques.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Deux chaînes peuvent être comparées à l’aide de règles de CompareInfo.Compare tri de chaîne en appelant les surcharges de méthode qui ont un CompareOptions.StringSort options paramètre fourni comme valeur.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Notez qu’il s’agit de la seule méthode que .NET fournit pour comparer deux chaînes à l’aide de règles de tri de chaîne.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Un tri ordinal compare des chaînes en fonction de la valeur numérique Char de chaque objet de la chaîne.An ordinal sort compares strings based on the numeric value of each Char object in the string. Une comparaison ordinale respecte automatiquement la casse, car les versions minuscules et majuscules d’un caractère ont des points de code différents.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Toutefois, si la casse n’est pas importante, vous pouvez spécifier une comparaison ordinale qui ignore la casse.However, if case is not important, you can specify an ordinal comparison that ignores case. Cela équivaut à convertir la chaîne en majuscules à l’aide de la culture dite indifférente, puis à effectuer une comparaison ordinale sur le résultat.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Pour obtenir la String liste des méthodes qui comparent deux chaînes à l’aide de règles de tri ordinal, consultez la section opérations de chaîne par catégorie .For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Une comparaison dépendante de la culture est toute comparaison qui utilise explicitement ou CultureInfo implicitement un objet, y compris la culture dite indifférente spécifiée par la CultureInfo.InvariantCulture propriété.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. La culture implicite est la culture actuelle, qui est spécifiée par Thread.CurrentCulture les CultureInfo.CurrentCulture propriétés et.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Il existe une variation considérable de l’ordre de tri des caractères alphabétiques (autrement dit, des caractères Char.IsLetter pour lesquels truela propriété retourne) entre les cultures.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Vous pouvez spécifier une comparaison dépendante de la culture qui utilise les conventions d’une culture spécifique en CultureInfo fournissant un objet à une méthode de comparaison Compare(String, String, CultureInfo, CompareOptions)de chaînes telle que.You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Vous pouvez spécifier une comparaison dépendante de la culture qui utilise les conventions de la culture actuelle StringComparison.CurrentCultureen StringComparison.CurrentCultureIgnoreCasefournissant, ou tout membre de CompareOptions l’énumération CompareOptions.Ordinal autre CompareOptions.OrdinalIgnoreCase que ou à un approprié surcharge de la Compare méthode.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Une comparaison dépendante de la culture est généralement appropriée pour le tri, contrairement à une comparaison ordinale.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Une comparaison ordinale est généralement appropriée pour déterminer si deux chaînes sont égales (autrement dit, pour déterminer l’identité) alors qu’il ne s’agit pas d’une comparaison dépendante de la culture.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

L’exemple suivant illustre la différence entre la comparaison dépendante de la culture et la comparaison ordinale.The following example illustrates the difference between culture-sensitive and ordinal comparison. L’exemple évalue trois chaînes, «Apple», «Æble» et «AEble», à l’aide de la comparaison ordinale et des conventions des cultures da-DK et en-US (chacune d’elles étant la culture par défaut Compare au moment où la méthode est appelée).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Étant donné que la langue danoise traite le caractère «Æ» comme une lettre individuelle et la trie après «Z» dans l’alphabet, la chaîne «Æble» est supérieure à «Apple».Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". Toutefois, «Æble» n’est pas considéré comme équivalent à «AEble», donc «Æble» est également supérieur à «AEble».However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". La culture en-US n’inclut pas la lettre «Æ», mais la considère comme équivalant à «AE», ce qui explique pourquoi «Æble» est inférieur à «Apple» mais est égal à «AEble».The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Par ailleurs, la comparaison ordinale considère que «Apple» est inférieur à «Æble» et «Æble» est supérieur à «AEble».Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

Utilisez les instructions générales suivantes pour choisir une méthode de tri ou de comparaison de chaînes appropriée:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Si vous souhaitez que les chaînes soient triées en fonction de la culture de l’utilisateur, vous devez les classer en fonction des conventions de la culture actuelle.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Si la culture de l’utilisateur change, l’ordre des chaînes triées est également modifié en conséquence.If the user's culture changes, the order of sorted strings will also change accordingly. Par exemple, une application de dictionnaire des synonymes doit toujours trier les mots en fonction de la culture de l’utilisateur.For example, a thesaurus application should always sort words based on the user's culture.

  • Si vous souhaitez que les chaînes soient triées en fonction des conventions d’une culture spécifique, vous devez les ordonner en fournissant CultureInfo un objet qui représente cette culture à une méthode de comparaison.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Par exemple, dans une application conçue pour enseigner aux élèves une langue particulière, vous souhaitez que les chaînes soient classées en fonction des conventions de l’une des cultures qui le parle.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Si vous souhaitez que l’ordre des chaînes reste inchangé entre les cultures, vous devez les classer en fonction des conventions de la culture dite indifférente ou utiliser une comparaison ordinale.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Par exemple, vous pouvez utiliser un tri ordinal pour organiser les noms de fichiers, les processus, les mutex ou les canaux nommés.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Pour une comparaison qui implique une décision de sécurité (par exemple, si un nom d’utilisateur est valide), vous devez toujours effectuer un test ordinal d’égalité en appelant Equals une surcharge de la méthode.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Notes

Les règles de tri et de casse dépendantes de la culture utilisées dans la comparaison de chaînes dépendent de la version du .NET.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. Dans le .NET Framework 4,5 et les versions ultérieures s' Windows 8Windows 8 exécutant sur le système d’exploitation, le tri, la casse, la normalisation et les informations sur les caractères Unicode sont conformes à la norme Unicode 6,0.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. Sur les autres systèmes d’exploitation Windows, il est conforme à la norme Unicode 5,0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. Sur .NET Core, cela dépend de la version de la norme Unicode prise en charge par le système d’exploitation sous-jacent.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Pour plus d’informations sur les règles de tri par mot, chaîne et ordinal System.Globalization.CompareOptions , consultez la rubrique.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Pour obtenir des recommandations supplémentaires sur l’utilisation de chaque règle, consultez meilleures pratiques pour l’utilisation de chaînes.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

En règle générale, vous n’appelez pas les méthodes de Compare Comparaison de chaînes telles que directement pour déterminer l’ordre de tri des chaînes.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Au lieu de cela, les méthodes de comparaison sont appelées List<T>.Sortpar des méthodes de tri telles que Array.Sort ou.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. L’exemple suivant effectue quatre opérations de tri différentes (tri alphabétique à l’aide de la culture actuelle, tri de mot à l’aide de la culture dite indifférente, tri ordinal et tri de chaîne à l’aide de la culture dite indifférente) sans appeler explicitement une méthode de comparaison de chaînes. Bien qu’elles spécifient le type de comparaison à utiliser.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Notez que chaque type de tri produit un classement unique des chaînes dans son tableau.Note that each type of sort produces a unique ordering of strings in its array.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Conseil

En interne, .NET utilise des clés de tri pour prendre en charge la comparaison de chaînes sensible à la culture.Internally, .NET uses sort keys to support culturally sensitive string comparison. Chaque caractère d'une chaîne se voit attribuer plusieurs pondérations de tri, notamment les pondérations alphabétiques, de casse et diacritiques.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Une clé de tri, représentée par SortKey la classe, fournit un référentiel de ces pondérations pour une chaîne particulière.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Si votre application effectue un grand nombre d’opérations de recherche ou de tri sur le même jeu de chaînes, vous pouvez améliorer ses performances en générant et en stockant des clés de tri pour toutes les chaînes qu’elle utilise.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Quand une opération de tri ou de comparaison est requise, vous utilisez les clés de tri à la place des chaînes.When a sort or comparison operation is required, you use the sort keys instead of the strings. Pour plus d'informations, consultez la classe SortKey.For more information, see the SortKey class.

Si vous ne spécifiez pas de Convention de comparaison de chaînes, Array.Sort(Array) les méthodes de tri telles que effectuent un tri dépendante de la culture et sensible à la casse sur les chaînes.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. L’exemple suivant illustre la façon dont la modification de la culture actuelle affecte l’ordre des chaînes triées dans un tableau.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Il crée un tableau de trois chaînes.It creates an array of three strings. D'abord, cela définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture sur la valeur en-US, et appelle la méthode Array.Sort(Array).First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. L’ordre de tri résultant est basé sur les conventions de tri pour la culture anglais (États-Unis).The resulting sort order is based on sorting conventions for the English (United States) culture. Ensuite, l'exemple définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture sur da-DK et appelle à nouveau la méthode Array.Sort.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Notez la façon dont l'utilisation des conventions de tri définies pour la culture danoise (Danemark) aboutit à un ordre de tri différent de celui obtenu pour la culture en-US.Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

Avertissement

Si votre objectif principal dans la comparaison de chaînes est de déterminer si elles sont égales, vous String.Equals devez appeler la méthode.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. En général, vous devez Equals utiliser pour effectuer une comparaison ordinale.Typically, you should use Equals to perform an ordinal comparison. La String.Compare méthode est principalement destinée au tri des chaînes.The String.Compare method is intended primarily to sort strings.

Les méthodes de recherche de chaînes String.StartsWith , String.IndexOftelles que et, peuvent également effectuer des comparaisons de chaînes dépendantes de la culture ou ordinales.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. L’exemple suivant illustre les différences entre les comparaisons ordinales et dépendantes de IndexOf la culture à l’aide de la méthode.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Une recherche dépendante de la culture dans laquelle la culture actuelle est l’anglais (États-Unis) considère la sous-chaîne «OE» pour qu’elle corresponde à la ligature «type».A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Comme un trait d’union conditionnel (U + 00AD) est un caractère de largeur nulle, la recherche traite le trait d’Union Empty conditionnel comme équivalent à et trouve une correspondance au début de la chaîne.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Une recherche ordinale, en revanche, ne trouve pas de correspondance dans les deux cas.An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

Rechercher des chaînesSearching Strings

Les méthodes de recherche de chaînes String.StartsWith , String.IndexOftelles que et, peuvent également effectuer des comparaisons de chaînes dépendantes de la culture ou ordinales pour déterminer si un caractère ou une sous-chaîne est trouvé dans une chaîne spécifiée.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

Les méthodes de recherche de String la classe qui recherchent un caractère individuel, tel que IndexOf la méthode, ou l’un des jeux de caractères, tels que IndexOfAny la méthode, effectuent toutes une recherche ordinale.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Pour effectuer une recherche dépendante de la culture d’un caractère, vous CompareInfo devez appeler une CompareInfo.IndexOf(String, Char) méthode CompareInfo.LastIndexOf(String, Char)telle que ou.To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Notez que les résultats de la recherche d’un caractère à l’aide d’un ordinal et d’une comparaison dépendante de la culture peuvent être très différents.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Par exemple, la recherche d’un caractère Unicode précomposé tel que la ligature «Æ» (U + 00C6) peut correspondre à n’importe quelle occurrence de ses composants dans l’ordre correct, par exemple «AE» (U + 041U + 0045), selon la culture.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. L’exemple suivant illustre la différence entre les String.IndexOf(Char) méthodes et CompareInfo.IndexOf(String, Char) lors de la recherche d’un caractère individuel.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. La ligature «æ» (U + 00E6) se trouve dans la chaîne «aérienne» lors de l’utilisation des conventions de la culture en-US, mais pas lors de l’utilisation des conventions de la culture da-DK ou lors de l’exécution d’une comparaison ordinale.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

En revanche, String les méthodes de classe qui recherchent une chaîne plutôt qu’un caractère effectuent une recherche dépendante de la culture si les options de recherche ne sont pas StringComparisonexplicitement spécifiées par un paramètre de type.On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. La seule exception est Contains, qui effectue une recherche ordinale.The sole exception is Contains, which performs an ordinal search.

Test de l’égalitéTesting for equality

Utilisez la String.Compare méthode pour déterminer la relation entre deux chaînes dans l’ordre de tri.Use the String.Compare method to determine the relationship of two strings in the sort order. En règle générale, il s’agit d’une opération dépendante de la culture.Typically, this is a culture-sensitive operation. En revanche, appelez la String.Equals méthode pour tester l’égalité.In contrast, call the String.Equals method to test for equality. Étant donné que le test d’égalité compare généralement l’entrée de l’utilisateur avec une chaîne connue, telle qu’un nom d’utilisateur valide, un mot de passe ou un chemin d’accès au système de fichiers, il s’agit généralement d’une opération ordinale.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Avertissement

Il est possible de tester l’égalité en appelant la String.Compare méthode et en déterminant si la valeur de retour est égale à zéro.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Toutefois, cette pratique n’est pas recommandée.However, this practice is not recommended. Pour déterminer si deux chaînes sont égales, vous devez appeler l’une des surcharges de String.Equals la méthode.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. La surcharge par défaut à appeler est la méthode Equals(String, StringComparison) d’instance ou la Equals(String, String, StringComparison) méthode statique, car les deux méthodes System.StringComparison incluent un paramètre qui spécifie explicitement le type de comparaison.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

L’exemple suivant illustre le risque d’effectuer une comparaison dépendante de la culture pour l’égalité lorsqu’un nombre ordinal doit être utilisé à la place.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. Dans ce cas, l’objectif du code est d’interdire l’accès au système de fichiers à partir d’URL qui commencent par «FILE://» ou «file://» en effectuant une comparaison ne respectant pas la casse du début d’une URL avec la chaîne «FILE://».In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Toutefois, si une comparaison dépendante de la culture est effectuée à l’aide de la culture turque (Turquie) sur une URL qui commence par «file://», la comparaison d’égalité échoue, car l’équivalent en majuscules turc de la minuscule «i» est «i» au lieu de «I».However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Par conséquent, l’accès au système de fichiers est autorisé par inadvertance.As a result, file system access is inadvertently permitted. En revanche, si une comparaison ordinale est effectuée, la comparaison d’égalité est établie et l’accès au système de fichiers est refusé.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

NormalisationNormalization

Certains caractères Unicode ont plusieurs représentations.Some Unicode characters have multiple representations. Par exemple, l’un des points de code suivants peut représenter la lettre «ắ»:For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

  • U+0103 U+0301U+0103 U+0301

  • U+0061 U+0306 U+0301U+0061 U+0306 U+0301

Plusieurs représentations pour un seul caractère compliquent la recherche, le tri, la correspondance et d’autres opérations de chaînes.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire d’un caractère Unicode pour l’une de ses représentations binaires équivalentes.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. La normalisation peut utiliser plusieurs algorithmes, appelés formulaires de normalisation, qui suivent différentes règles.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET prend en charge les formulaires de normalisation Unicode C, D, KC et KD..NET supports Unicode normalization forms C, D, KC, and KD. Lorsque les chaînes ont été normalisées selon le même formulaire de normalisation, elles peuvent être comparées à l’aide de la comparaison ordinale.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Une comparaison ordinale est une comparaison binaire de la valeur scalaire Unicode des Char objets correspondants dans chaque chaîne.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. La String classe inclut un certain nombre de méthodes qui peuvent effectuer une comparaison ordinale, y compris les éléments suivants:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Vous pouvez déterminer si une chaîne est normalisée en formulaire de normalisation C en appelant la String.IsNormalized() méthode, ou vous pouvez appeler la String.IsNormalized(NormalizationForm) méthode pour déterminer si une chaîne est normalisée à un formulaire de normalisation spécifié.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. Vous pouvez également appeler la String.Normalize() méthode pour convertir une chaîne en formulaire de normalisation C, ou vous pouvez appeler la String.Normalize(NormalizationForm) méthode pour convertir une chaîne en un formulaire de normalisation spécifié.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Pour obtenir des informations pas à pas sur la normalisation et la comparaison de chaînes, Normalize() consultez Normalize(NormalizationForm) les méthodes et.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

L’exemple simple suivant illustre la normalisation des chaînes.The following simple example illustrates string normalization. Elle définit la lettre «ố» de trois façons différentes dans trois chaînes différentes et utilise une comparaison ordinale pour déterminer si chaque chaîne diffère des deux autres chaînes.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Il convertit ensuite chaque chaîne en formulaires de normalisation pris en charge, et effectue à nouveau une comparaison ordinale de chaque chaîne dans un formulaire de normalisation spécifié.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. Dans chaque cas, le deuxième test d’égalité indique que les chaînes sont égales.In each case, the second test for equality shows that the strings are equal.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Pour plus d’informations sur les formulaires de normalisation et de normalisation System.Text.NormalizationForm, consultez, ainsi que l’annexe Unicode standard #15: Les formulaires de normalisation Unicode et le Forum aux questions sur la normalisation sur le site Web Unicode.org.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Opérations de chaîne par catégorieString operations by category

La String classe fournit des membres pour la comparaison de chaînes, le test d’égalité de chaînes, la recherche de caractères ou de sous-chaînes dans une chaîne, la modification d’une chaîne, l’extraction de sous-chaînes d’une chaîne, la combinaison de chaînes, la mise en forme des valeurs, la copie d’une chaîne et normalisation d’une chaîne.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Comparaison de chaînesComparing strings

Vous pouvez comparer des chaînes pour déterminer leur position relative dans l’ordre de tri à l' String aide des méthodes suivantes:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compareretourne un entier qui indique la relation entre une chaîne et une seconde chaîne dans l’ordre de tri.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalretourne un entier qui indique la relation entre une chaîne et une deuxième chaîne, en fonction d’une comparaison de leurs points de code.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareToretourne un entier qui indique la relation de l’instance de chaîne actuelle avec une deuxième chaîne dans l’ordre de tri.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. La CompareTo(String) méthode fournit les IComparable implémentations et IComparable<T> pour la String classe.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Test d’égalité de chaînesTesting strings for equality

Vous appelez la Equals méthode pour déterminer si deux chaînes sont égales.You call the Equals method to determine whether two strings are equal. L’instance Equals(String, String, StringComparison) et les surcharges statiques Equals(String, StringComparison) vous permettent de spécifier si la comparaison est dépendante de la culture ou ordinale, et si la casse est prise en compte ou ignorée.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. La plupart des tests d’égalité sont ordinaux, et les comparaisons d’égalité qui déterminent l’accès à une ressource système (par exemple, un objet de système de fichiers) doivent toujours être ordinales.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Recherche de caractères dans une chaîneFinding characters in a string

La String classe comprend deux types de méthodes de recherche:The String class includes two kinds of search methods:

Avertissement

Si vous souhaitez rechercher une chaîne pour un modèle particulier plutôt qu’une sous-chaîne spécifique, vous devez utiliser des expressions régulières.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Pour plus d’informations, consultez expressions régulières .net.For more information, see .NET Regular Expressions.

Modification d’une chaîneModifying a string

La String classe comprend les méthodes suivantes qui s’affichent pour modifier la valeur d’une chaîne:The String class includes the following methods that appear to modify the value of a string:

  • Insertinsère une chaîne dans l’instance actuelle String .Insert inserts a string into the current String instance.

  • PadLeftinsère une ou plusieurs occurrences d’un caractère spécifié au début d’une chaîne.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRightinsère une ou plusieurs occurrences d’un caractère spécifié à la fin d’une chaîne.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Removesupprime une sous-chaîne de l’instance String actuelle.Remove deletes a substring from the current String instance.

  • Replaceremplace une sous-chaîne par une autre sous-chaîne String dans l’instance actuelle.Replace replaces a substring with another substring in the current String instance.

  • ToLoweret ToLowerInvariant convertissent tous les caractères d’une chaîne en minuscules.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpperet ToUpperInvariant convertissent tous les caractères d’une chaîne en majuscules.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trimsupprime toutes les occurrences d’un caractère à partir du début et de la fin d’une chaîne.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEndsupprime toutes les occurrences d’un caractère à la fin d’une chaîne.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStartsupprime toutes les occurrences d’un caractère à partir du début d’une chaîne.TrimStart removes all occurrences of a character from the beginning of a string.

Important

Toutes les méthodes de modification de chaîne String retournent un nouvel objet.All string modification methods return a new String object. Elles ne modifient pas la valeur de l’instance actuelle.They don't modify the value of the current instance.

Extraction de sous-chaînes à partir d’une chaîneExtracting substrings from a string

La String.Split méthode sépare une chaîne unique en plusieurs chaînes.The String.Split method separates a single string into multiple strings. Les surcharges de la méthode vous permettent de spécifier plusieurs séparateurs, de déterminer le nombre maximal de sous-chaînes extraites par la méthode et de déterminer si les chaînes vides (qui se produisent lorsque les délimiteurs sont adjacents) sont incluses parmi les chaînes retournées.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Combiner des chaînesCombining strings

Les méthodes String suivantes peuvent être utilisées pour la concaténation de chaînes:The following String methods can be used for string concatenation:

  • Concatcombine une ou plusieurs sous-chaînes en une seule chaîne.Concat combines one or more substrings into a single string.

  • Joinconcatène une ou plusieurs sous-chaînes en un seul élément et ajoute un séparateur entre chaque sous-chaîne.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Mise en forme des valeursFormatting values

La String.Format méthode utilise la fonctionnalité de mise en forme composite pour remplacer un ou plusieurs espaces réservés dans une chaîne par la représentation sous forme de chaîne d’un objet ou d’une valeur.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. La Format méthode est souvent utilisée pour effectuer les opérations suivantes:The Format method is often used to do the following:

  • Pour incorporer la représentation sous forme de chaîne d’une valeur numérique dans une chaîne.To embed the string representation of a numeric value in a string.

  • Pour incorporer la représentation sous forme de chaîne d’une valeur de date et d’heure dans une chaîne.To embed the string representation of a date and time value in a string.

  • Pour incorporer la représentation sous forme de chaîne d’une valeur d’énumération dans une chaîne.To embed the string representation of an enumeration value in a string.

  • Pour incorporer la représentation sous forme de chaîne d’un IFormattable objet qui prend en charge l’interface dans une chaîne.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Pour justifier à droite ou à gauche une sous-chaîne dans un champ d’une chaîne plus grande.To right-justify or left-justify a substring in a field within a larger string.

Pour plus d’informations sur les opérations de mise en forme et Format des exemples, consultez le résumé de surcharge.For detailed information about formatting operations and examples, see the Format overload summary.

Copie d’une chaîneCopying a string

Vous pouvez appeler les méthodes String suivantes pour effectuer une copie d’une chaîne:You can call the following String methods to make a copy of a string:

  • Cloneretourne une référence à un objet String existant.Clone returns a reference to an existing String object.

  • Copycrée une copie d’une chaîne existante.Copy creates a copy of an existing string.

  • CopyTocopie une partie d’une chaîne dans un tableau de caractères.CopyTo copies a portion of a string to a character array.

Normalisation d’une chaîneNormalizing a string

En Unicode, un caractère unique peut avoir plusieurs points de code.In Unicode, a single character can have multiple code points. La normalisation convertit ces caractères équivalents dans la même représentation binaire.Normalization converts these equivalent characters into the same binary representation. La String.Normalize méthode effectue la normalisation et la String.IsNormalized méthode détermine si une chaîne est normalisée.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Pour plus d’informations et pour obtenir un exemple, consultez la section normalisation plus haut dans cette rubrique.For more information and an example, see the Normalization section earlier in this topic.

Constructeurs

String(Char*) String(Char*) String(Char*) String(Char*)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un caractère Unicode spécifié et répété un certain nombre de fois.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode, une position de départ de caractère dans ce tableau et une longueur.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur vers un tableau d'entiers signés 8 bits.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau et une longueur.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un objet Encoding.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Champs

Empty Empty Empty Empty

Représente la chaîne vide.Represents the empty string. Ce champ est en lecture seule.This field is read-only.

Propriétés

Chars[Index] Chars[Index] Chars[Index] Chars[Index]
Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Obtient l'objet Char à une position de caractère spécifiée dans l'objet String actuel.Gets the Char object at a specified position in the current String object.

Chars[Range] Chars[Range] Chars[Range] Chars[Range]
Length Length Length Length

Obtient le nombre de caractères de l'objet String actuel.Gets the number of characters in the current String object.

Méthodes

Clone() Clone() Clone() Clone()

Retourne une référence à cette instance de String.Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

Compare les sous-chaînes de deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

Compare les sous-chaînes de deux objets String spécifiés, en ignorant ou en respectant leur casse, et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Compare les sous-chaînes de deux objets String spécifiés, en ignorant ou en respectant leur casse et en utilisant les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Compare des sous-chaînes de deux objets String spécifiés en utilisant les options de comparaison spécifiées et les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique la relation entre ces deux sous-chaînes dans l'ordre de tri.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

Compare les sous-chaînes de deux objets String spécifiés à l'aide des règles désignées et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

Compare deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

Compare deux objets String spécifiés, en ignorant ou en respectant leur casse, et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

Compare deux objets String spécifiés, en ignorant ou en respectant leur casse et en utilisant les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

Compare deux objets String spécifiés en utilisant les options de comparaison spécifiées et les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique la relation entre ces deux chaînes dans l'ordre de tri.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

Compare deux objets String spécifiés à l'aide des règles désignées et retourne un entier qui indique leur position relative dans l'ordre de tri.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

Compare les sous-chaînes de deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondants de chaque sous-chaîne.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

Compare deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondants dans chaque chaîne.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compare cette instance avec un Object spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que le Object spécifié.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

Compare cette instance avec un objet String spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que la chaîne spécifiée.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Concatène les membres d'une collection IEnumerable<T> construite de type String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Crée la représentation sous forme de chaîne d'un objet spécifié.Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Concatène les représentations sous forme de chaîne de deux objets spécifiés.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Concatène les représentations sous forme de chaîne de trois objets spécifiés.Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Concatène les représentations sous forme de chaîne de quatre objets spécifiés et de tous les objets spécifiés dans une liste facultative de paramètres de longueur variable.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Concatène les représentations sous forme de chaîne des éléments dans un tableau Object spécifié.Concatenates the string representations of the elements in a specified Object array.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de deux étendues de caractères en lecture seule spécifiées.Concatenates the string representations of two specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de trois étendues de caractères en lecture seule spécifiées.Concatenates the string representations of three specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de quatre étendues de caractères en lecture seule spécifiées.Concatenates the string representations of four specified read-only character spans.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Concatène deux instances spécifiées de String.Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Concatène trois instances spécifiées de String.Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Concatène quatre instances spécifiées de String.Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Concatène les éléments d'un tableau String spécifié.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Concatène les membres d'une implémentation IEnumerable<T>.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)

Retourne une valeur qui indique si le caractère spécifié se trouve dans cette chaîne.Returns a value indicating whether a specified character occurs within this string.

Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)

Retourne une valeur qui indique si le caractère spécifié se trouve dans cette chaîne, en utilisant les règles de comparaison spécifiées.Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String) Contains(String) Contains(String) Contains(String)

Retourne une valeur qui indique si la sous-chaîne spécifiée apparaît dans cette chaîne.Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)

Retourne une valeur qui indique si la chaîne spécifiée se trouve dans cette chaîne, en utilisant les règles de comparaison spécifiées.Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String) Copy(String) Copy(String) Copy(String)

Crée une instance de String ayant la même valeur qu'un String spécifié.Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

Copie un nombre spécifié de caractères à partir d'une position spécifiée dans cette instance vers une position spécifiée dans un tableau de caractères Unicode.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes() EnumerateRunes() EnumerateRunes() EnumerateRunes()

Retourne une énumération de Rune à partir de cette chaîne.Returns an enumeration of Rune from this string.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

Détermine si cette instance et un autre objet String spécifié ont la même valeur.Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

Détermine si deux objets String spécifiés ont la même valeur.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

Détermine si deux objets String spécifiés ont la même valeur.Determines whether two specified String objects have the same value. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

Détermine si cette chaîne et un objet String spécifié ont la même valeur.Determines whether this string and a specified String object have the same value. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés.Replaces the format items in a string with the string representation of two specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.Replaces the format items in a string with the string representation of three specified objects. Un paramètre fournit des informations de mise en forme propres à la culture.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Remplace les éléments de mise en forme d’une chaîne par les représentations sous forme de chaîne des objets correspondants dans un tableau spécifié.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un paramètre fournit des informations de mise en forme propres à la culture.A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés.Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Récupère un objet qui peut itérer au sein des caractères individuels de cette chaîne.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne le code de hachage pour cette chaîne.Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>)

Retourne le code de hachage pour l’étendue de caractères en lecture seule fournie.Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison)

Retourne le code de hachage pour l’étendue de caractères en lecture seule fournie, en utilisant les règles spécifiées.Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)

Retourne le code de hachage pour cette chaîne à l’aide des règles spécifiées.Returns the hash code for this string using the specified rules.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

Retourne une référence à l’élément de la chaîne à l’index zéro.Returns a reference to the element of the string at index zero.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Retourne TypeCode pour la classe String.Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. La recherche commence à une position de caractère spécifiée.The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

Signale l'index de base zéro de la première occurrence du caractère spécifié dans cette instance.Reports the zero-based index of the first occurrence of the specified character in this instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Un paramètre spécifie le type de recherche à utiliser pour le caractère spécifié.A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.Reports the zero-based index of the first occurrence of the specified string in this instance. La recherche commence à une position de caractère spécifiée.The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.Reports the zero-based index of the first occurrence of the specified string in this instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the first occurrence of the specified string in the current String object. Les paramètres spécifient le point de départ de la recherche dans la chaîne actuelle, le nombre de caractères de la chaîne dans laquelle effectuer la recherche et le type de recherche à utiliser pour la chaîne spécifiée.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the first occurrence of the specified string in the current String object. Les paramètres spécifient la position de départ de la recherche dans la chaîne actuelle et le type de recherche à utiliser pour la chaîne spécifiée.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the first occurrence of the specified string in the current String object. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La recherche commence à une position de caractère spécifiée.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Retourne une nouvelle chaîne dans laquelle une chaîne spécifiée est insérée dans cette instance à une position d'index spécifiée.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

Récupère la référence du système au String spécifié.Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

Récupère une référence à un String spécifié.Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

Indique si cette chaîne figure dans le formulaire de normalisation Unicode spécifié.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

Indique si la chaîne spécifiée est null ou une chaîne vide ("").Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

Indique si une chaîne spécifiée est null, vide ou se compose uniquement d'espaces blancs.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

Concatène les membres d’une collection IEnumerable<T> construite de type String, en utilisant le séparateur spécifié entre chaque membre.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

Concatène les éléments d'un tableau d'objets, en utilisant le séparateur spécifié entre chaque élément.Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

Concatène tous les éléments d'un tableau de chaînes, en utilisant le séparateur spécifié entre chaque élément.Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

Concatène les éléments spécifiés d'un tableau de chaînes, en utilisant le séparateur spécifié entre chaque élément.Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

Concatène les membres d’une collection, en utilisant le séparateur spécifié entre chaque membre.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence du caractère Unicode spécifié dans une sous-chaîne de cette instance.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour le nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans un formulaire de normalisation C Unicode.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans le formulaire de normalisation Unicode spécifié.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

Retourne une nouvelle chaîne qui aligne les caractères de cette instance à droite en les complétant par des espaces à gauche pour une longueur totale spécifiée.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

Retourne une nouvelle chaîne qui aligne les caractères de cette instance à droite en les complétant par un caractère Unicode spécifié à gauche pour une longueur totale spécifiée.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

Retourne une nouvelle chaîne qui aligne les caractères de cette chaîne à gauche en les complétant par des espaces à droite pour une longueur totale spécifiée.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

Retourne une nouvelle chaîne qui aligne les caractères de cette chaîne à gauche en les complétant par un caractère Unicode spécifié à droite pour une longueur totale spécifiée.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

Retourne une nouvelle chaîne dans laquelle tous les caractères de l'instance actuelle ont été supprimés à partir d'une position spécifiée et jusqu'à la dernière position.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Retourne une nouvelle chaîne dans laquelle un nombre spécifié de caractères a été supprimé dans l'instance actuelle à partir d'une position spécifiée.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'un caractère Unicode spécifié dans cette instance sont remplacées par un autre caractère Unicode spécifié.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'une chaîne spécifiée dans l'instance actuelle sont remplacées par une autre chaîne spécifiée.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Divise une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into a maximum number of substrings based on the characters in an array. Vous pouvez aussi spécifier le nombre maximal de sous-chaînes à retourner.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Fractionne une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.Splits a string into substrings based on the characters in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into a maximum number of substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Fractionne une chaîne en sous-chaînes en fonction des chaînes contenues dans un tableau.Splits a string into substrings based on the strings in an array. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Index) Substring(Index) Substring(Index) Substring(Index)
Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Récupère une sous-chaîne de cette instance.Retrieves a substring from this instance. La sous-chaîne commence à une position de caractère spécifiée et continue jusqu'à la fin de la chaîne.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Récupère une sous-chaîne de cette instance.Retrieves a substring from this instance. La sous-chaîne commence à une position de caractère spécifiée et sa longueur est définie.The substring starts at a specified character position and has a specified length.

Substring(Range) Substring(Range) Substring(Range) Substring(Range)
ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Copie les caractères de cette instance vers un tableau de caractères Unicode.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

Copie les caractères d'une sous-chaîne spécifiée de cette instance vers un tableau de caractères Unicode.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

Retourne une copie de cette chaîne convertie en minuscules.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

Retourne une copie de cette chaîne en minuscules, à l'aide des règles de casse de la culture spécifiée.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

Retourne une copie de cet objet String converti en minuscules à l'aide des règles de casse de la culture indifférente.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

Retourne cette instance de String ; aucune conversion n'est effectivement effectuée.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Retourne cette instance de String ; aucune conversion n'est effectivement effectuée.Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

Retourne une copie de cette chaîne convertie en majuscules.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

Retourne une copie de cette chaîne convertie en majuscules à l'aide des règles de casse de la culture spécifiée.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

Retourne une copie de cet objet String converti en majuscules à l'aide des règles de casse de la culture indifférente.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

Supprime tous les espaces blancs de début ou de fin de chaîne de l'objet String actuel.Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

Supprime toutes les occurrences de début et de fin d'un jeu de caractères spécifiés d'un tableau dans un objet String.Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

Supprime, de l'objet String actuel, toutes les occurrences situées à la fin d'un jeu de caractères spécifiés dans un tableau.Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

Supprime, de l'objet String actuel, toutes les occurrences situées au début d'un jeu de caractères spécifiés dans un tableau.Removes all leading occurrences of a set of characters specified in an array from the current String object.

Opérateurs

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

Détermine si deux chaînes spécifiées ont la même valeur.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

Détermine si deux chaînes spécifiées ont des valeurs différentes.Determines whether two specified strings have different values.

Implémentations d’interfaces explicites

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToChar(IFormatProvider).For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDateTime(IFormatProvider).For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein de l'objet String actuel.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

Retourne un énumérateur qui itère au sein de l'objet String actuel.Returns an enumerator that iterates through the current String object.

Méthodes d’extension

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory(String) AsMemory(String) AsMemory(String) AsMemory(String)

Crée un ReadOnlyMemory<Char> sur la partie de la chaîne cible.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index)

Crée un ReadOnlyMemory<Char> sur une partie de la chaîne cible en commençant à un index spécifié.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32)

Crée un ReadOnlyMemory<Char> sur une partie de la chaîne cible en commençant à une position de caractère spécifiée.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32)

Crée un ReadOnlyMemory<Char> sur une partie de la chaîne cible en commençant à une position spécifiée avec une longueur.Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range)

Crée un ReadOnlyMemory<Char> sur une plage spécifiée de la chaîne cible.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String) AsSpan(String) AsSpan(String) AsSpan(String)

Crée une étendue en lecture seule sur une partie de la chaîne cible à une position spécifiée pour un nombre spécifié de caractères.Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32)

Crée une étendue en lecture seule sur une partie de la chaîne cible à une position spécifiée jusqu’à la fin de la chaîne.Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32)

Crée une étendue en lecture seule sur une chaîne.Creates a new read-only span over a string.

IsNormalized(String) IsNormalized(String) IsNormalized(String) IsNormalized(String)

Indique si la chaîne spécifiée figure dans un formulaire de normalisation Unicode C.Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm)

Indique si une chaîne figure dans un formulaire de normalisation Unicode spécifié.Indicates whether a string is in a specified Unicode normalization form.

Normalize(String) Normalize(String) Normalize(String) Normalize(String)

Normalise une chaîne en un formulaire de normalisation C Unicode.Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm)

Normalise une chaîne au formulaire de normalisation Unicode spécifié.Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi