String Classe

Définition

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerable

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerable

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerable

public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface IParsable<string>
    interface ISpanParsable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface ICloneable

[<System.Serializable>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IComparable<string>
    interface seq<char>
    interface IEnumerable
    interface IEquatable<string>

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>

type string = class
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>

type string = class
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
    interface seq<char>
    interface IEnumerable

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerable

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)

Héritage

Object

String

Attributs

SerializableAttribute ComVisibleAttribute

Implémente

IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable IParsable<String> IParsable<TSelf> ISpanParsable<String>

Remarques

Une chaîne est une collection séquentielle de caractères utilisés pour représenter du texte. Un String objet est une collection séquentielle d’objets System.Char qui représentent une chaîne ; un System.Char objet correspond à une unité de code UTF-16. La valeur de l’objet String est le contenu de la collection séquentielle d’objets System.Char , et cette valeur est immuable (autrement dit, elle est en lecture seule). Pour plus d’informations sur l’immuabilité des chaînes, consultez la section "Immutability and the StringBuilder class". La taille maximale d’un String objet en mémoire est de 2 Go ou environ 1 milliard de caractères.

Pour plus d’informations sur Unicode, UTF-16, les unités de code, les points de code et les types Char et Rune, consultez Introduction à l'encodage de caractères dans .NET.

Instancier un objet String

Vous pouvez instancier un String objet de la manière suivante :

• En affectant un littéral de chaîne à une String variable. Il s’agit de la méthode la plus couramment utilisée pour créer une chaîne. L’exemple suivant utilise l’affectation pour créer plusieurs chaînes. Notez que dans C# et F#, car la barre oblique inverse (\) est un caractère d’échappement, les barres obliques inverses littérales dans une chaîne doivent être échappées ou la chaîne entière doit être précédée d'un @.

  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
  

  let string1 = "This is a string created by assignment."
  printfn "%s" string1
  let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
  printfn "%s" string2a
  let string2b = @"The path is C:\PublicDocuments\Report1.doc"
  printfn "%s" 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. L’exemple suivant instancie les chaînes en appelant plusieurs constructeurs de classe. Notez que certains constructeurs incluent des pointeurs vers des tableaux de caractères ou des tableaux d’octets signés en tant que paramètres. Visual Basic ne prend pas en charge les appels à ces constructeurs. Pour plus d’informations sur les String constructeurs, consultez le résumé de constructeur String.

  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
  

  let chars = [| 'w'; 'o'; 'r'; 'd' |]
  let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]
  
  // Create a string from a character array.
  let string1 = String chars
  printfn "%s" string1
  
  // Create a string that consists of a character repeated 20 times.
  let string2 = String('c', 20)
  printfn "%s" string2
  
  let stringFromBytes =
      // Create a string from a pointer to a signed byte array.
      use pbytes = fixed bytes
      String pbytes
  let stringFromChars = 
      // Create a string from a pointer to a character array.
      use pchars = fixed chars
      String pchars
  
  printfn $"{stringFromBytes}"
  printfn $"{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îne (+ en C# et F#, et & ou + en Visual Basic) pour créer une chaîne unique à partir de n'importe quelle combinaison d'instances de et de littéraux de chaîne. L’exemple suivant illustre l’utilisation de l’opérateur de concaténation de chaîne.

  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.
  

  let string1 = "Today is " + DateTime.Now.ToString("D") + "."
  printfn $"{string1}"
  
  let string2 = "This is one sentence. " + "This is a second. "
  let string2 = string2 + "This is a third sentence."
  printfn $"{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 récupérant une propriété ou en appelant une méthode qui retourne une chaîne. L’exemple suivant utilise les méthodes de la String classe pour extraire une sous-chaîne d’une chaîne plus grande.

  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
  

  let sentence = "This sentence has five words."
  // Extract the second word.
  let startPosition = sentence.IndexOf " " + 1
  let word2 = 
      sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
  printfn $"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. 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.

  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.
  

  let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
  let temperature = 68.3
  String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
  |> printfn "%s"
  // 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 Unicode

Chaque caractère d’une chaîne est défini par une valeur scalaire Unicode, également appelée point de code Unicode ou valeur ordinale (numérique) du caractère Unicode. 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 est représentée par un Char objet.

Un objet unique Char représente généralement un point de code unique ; autrement dit, la valeur numérique de Char égale le point de code. Par exemple, le point de code du caractère « a » est U+0061. Toutefois, un point de code peut nécessiter plusieurs éléments encodés (plusieurs Char objets). La norme Unicode définit deux types de caractères qui correspondent à plusieurs Char objets : graphemes et points de code supplémentaires Unicode qui correspondent aux caractères dans les plans supplémentaires Unicode.

• Un grapheme est représenté par un caractère de base suivi d’un ou plusieurs caractères de combinaison. Par exemple, le caractère ä est représenté par un Char objet dont le point de code est U+0061 suivi d’un Char objet dont le point de code est U+0308. Ce caractère peut également être défini par un objet unique Char qui a un point de code U+00E4. Comme l’illustre l’exemple suivant, une comparaison sensible à la culture pour l’égalité indique que ces deux représentations sont égales, bien qu’une comparaison ordinale ordinaire ne le fasse pas. Toutefois, si les deux chaînes sont normalisées, une comparaison ordinale indique également qu’elles sont égales. (Pour plus d’informations sur la normalisation des chaînes, consultez la page Section normalisation .)

  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
  

  open System
  open System.IO
  
  do
      use sw = new StreamWriter(@".\graphemes.txt")
      let grapheme = "\u0061\u0308"
      sw.WriteLine grapheme
  
      let 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))
  // The example produces the following output:
  //       ä
  //       ä
  //       ä = ä (Culture-sensitive): True
  //       ä = ä (Ordinal): False
  //       ä = ä (Normalized Ordinal): True
  

  Imports System.Globalization
  Imports System.IO
  
  Module Example9
      Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H61) + ChrW(&H308)
          sw.WriteLine(grapheme)
  
          Dim singleChar As String = ChrW(&HE4)
          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 (paire de substitution) est représenté par un Char objet dont le point de code est un substitut élevé suivi d’un Char objet dont le point de code est un substitut faible. Les unités de code des suppléants élevés vont de U+D800 à U+DBFF. Les unités de code des basses substitutions vont de U+DC00 à U+DFFF. Les paires de substitution sont utilisées pour représenter des caractères dans les 16 plans supplémentaires Unicode. L’exemple suivant crée un caractère de substitution et le transmet à la Char.IsSurrogatePair(Char, Char) méthode pour déterminer s’il s’agit d’une paire de substitution.

  string surrogate = "\uD800\uDC03";
  for (int ctr = 0; ctr < surrogate.Length; ctr++) 
     Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
  
  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
  

  open System
  
  let surrogate = "\uD800\uDC03"
  for i = 0 to surrogate.Length - 1 do
      printf $"U+{uint16 surrogate[i]:X2} "
  
  printfn $"\n   Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}"
  // The example displays the following output:
  //       U+D800 U+DC03
  //          Is Surrogate Pair: True
  

  Module Example20
      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
  

Norme Unicode

Les caractères d’une chaîne sont représentés par des unités de code encodées UTF-16, qui correspondent aux Char valeurs.

Chaque caractère d’une chaîne a une catégorie de caractères Unicode associée, qui est représentée dans .NET par l’énumération UnicodeCategory . La catégorie d’un caractère ou d’une paire de substitution peut être déterminée en appelant la CharUnicodeInfo.GetUnicodeCategory méthode.

.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. Sur toutes les versions de .NET et sur toutes les plateformes de système d’exploitation, les informations de catégorie de caractères sont fournies par la base de données de caractères Unicode.

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.

Version de .NET	Version de la norme Unicode Standard
.NET Framework 1.1	The Unicode Standard, version 4.0.0
.NET Framework 2.0	The Unicode Standard, version 5.0.0
.NET Framework 3.5	The Unicode Standard, version 5.0.0
.NET Framework 4	The Unicode Standard, version 5.0.0
.NET Framework 4.5	The Unicode Standard, version 6.3.0
.NET Framework 4.5.1	The Unicode Standard, version 6.3.0
.NET Framework 4.5.2	The Unicode Standard, version 6.3.0
.NET Framework 4.6	The Unicode Standard, version 6.3.0
.NET Framework 4.6.1	The Unicode Standard, version 6.3.0
.NET Framework 4.6.2 et versions ultérieures	The Unicode Standard, version 8.0.0
.NET Core 2.1	The Unicode Standard, version 8.0.0
.NET Core 3.1	Norme Unicode, version 11.0.0
.NET 5	Le standard Unicode, version 13.0.0

En outre, .NET prend en charge la comparaison de chaînes et le tri en fonction de la norme Unicode. Les informations de comparaison et de tri des chaînes sont fournies par International Components for Unicode bibliothèques (sauf sur les versions Windows antérieures à la mise à jour de mai 2019 Windows 10 mai 2019).

Caractères nuls incorporés

Dans .NET, un String objet peut inclure des caractères null incorporés, qui comptent dans le cadre de la longueur de la chaîne. Toutefois, dans certains langages tels que C et C++, un caractère Null indique la fin d’une chaîne ; elle n’est pas considérée comme une partie de la chaîne et n’est pas comptabilisée dans le cadre de la longueur de la chaîne. Cela signifie que les hypothèses courantes suivantes que les programmeurs ou bibliothèques C et C++ écrits en C ou C++ peuvent faire sur les chaînes ne sont pas nécessairement valides lorsqu’ils sont appliqués aux String objets :

• La valeur retournée par les fonctions strlen ou wcslen n'est pas nécessairement égale à String.Length.

• La chaîne créée par la fonction strcpy_s ou wcscpy_s n’est pas nécessairement identique à la chaîne copiée.

Vous devez vous assurer que le code C et C++ natif qui instancie des String objets et le code auquel sont passés des objets String par invocation de plateforme ne suppose pas qu’un caractère nul incorporé marque la fin de la chaîne.

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 lorsqu’une chaîne est recherchée. Les caractères nuls sont ignorés lors de comparaisons sensibles à la culture entre deux chaînes, y compris les comparaisons à l’aide de la culture invariante. Ils sont considérés uniquement pour les comparaisons ordinales ou non sensibles à la casse. En revanche, les caractères null incorporés sont toujours pris en compte lors de la recherche d’une chaîne avec des méthodes telles que Contains, StartsWithet IndexOf.

Chaînes et index

Un index est la position d’un Char objet (et non d’un caractère Unicode) dans un String. Un index est un nombre non négatif basé sur zéro qui commence à partir de la première position de la chaîne, qui est la position d’index zéro. 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.

La Chars[Int32] propriété vous permet d’accéder à des objets individuels Char par leur position d’index dans la chaîne. Étant donné que la Chars[Int32] propriété est la propriété par défaut (en Visual Basic) ou l’indexeur (en C# et F#), vous pouvez accéder aux objets individuels Char d’une chaîne à l’aide de code tel que le suivant. Ce code recherche des espaces blancs ou des caractères de ponctuation dans une chaîne pour déterminer le nombre de mots que contient la chaîne.

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.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for i = 0 to s1.Length - 1 do
    if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

Module Example12
    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)) 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.

Étant donné que la String classe implémente l’interface IEnumerable, vous pouvez également itérer à travers les objets Char d’une chaîne de caractères à l’aide d’une foreach construction, comme l’illustre l’exemple suivant.

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.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

Module Example13
    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é en tant que plusieurs Char objets. En particulier, une chaîne peut contenir des unités à caractères multiples de texte formées par un caractère de base suivi d’un ou plusieurs caractères combinés ou par des paires de substitution. Pour utiliser des caractères Unicode au lieu d’objets Char , utilisez les System.Globalization.StringInfo classes TextElementEnumerator ou la String.EnumerateRunes méthode et le Rune struct. L’exemple suivant illustre la différence entre le code qui fonctionne avec Char des objets et du code qui fonctionne avec des caractères Unicode. Il compare le nombre de caractères ou d’éléments de texte dans chaque mot d’une phrase. La chaîne comprend deux séquences d’un caractère de base suivi d’un caractère combiné.

// 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

open System
open System.Globalization

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

for ch in opening do
    // Skip the ' character.
    if ch <> '\u0027' then
        if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
            chars.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
    let s = te.GetTextElement()
    // Skip the ' character.
    if s <> "\u0027" then
        if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
            elements.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
    printfn "%6d %20d %20d" i chars[i] elements[i]
// 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 Example14
    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(&H27) 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(&H27) Then Continue Do
            If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) Then
                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 des éléments de texte à l’aide de la méthode et de la StringInfo.GetTextElementEnumeratorTextElementEnumerator classe pour énumérer tous les éléments de texte d’une chaîne. Vous pouvez également récupérer un tableau qui contient l’index de départ de chaque élément de texte en appelant la StringInfo.ParseCombiningCharacters méthode.

Pour plus d’informations sur l’utilisation d’unités de texte plutôt que de valeurs individuelles Char , consultez Introduction à l’encodage de caractères dans .NET.

Chaînes Null et chaînes vides

Une chaîne qui a été déclarée mais qui n’a pas été affectée à une valeur est null. La tentative d’appel de méthodes sur cette chaîne lève un NullReferenceException. Une chaîne null est différente d’une chaîne vide, qui est une chaîne dont la valeur est « » ou 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. Par exemple, le passage d’une chaîne Null à la Int32.Parse méthode lève un ArgumentNullException, et le passage d’une chaîne vide lève un FormatException. Dans d’autres cas, un argument de méthode peut être une chaîne Null ou une chaîne vide. Par exemple, si vous fournissez une IFormattable implémentation pour une classe, vous souhaitez assimiler à la fois une chaîne null et une chaîne vide avec le spécificateur de format général (« G »).

La String classe inclut les deux méthodes pratiques suivantes qui vous permettent de tester si une chaîne est null ou vide :

• IsNullOrEmpty, qui indique si une chaîne est égale null ou égale à String.Empty. Cette méthode élimine la nécessité d’utiliser du code comme suit :

  if (str == null || str.Equals(String.Empty))
  

  if str = null || str.Equals String.Empty then
  

  If str Is Nothing OrElse str.Equals(String.Empty) Then
  

• IsNullOrWhiteSpace, qui indique si une chaîne est null, est égale String.Emptyou se compose exclusivement de caractères d’espace blanc. Cette méthode élimine la nécessité d’utiliser du code comme suit :

  if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
  

  if str = null || str.Equals String.Empty || str.Trim().Equals String.Empty then
  

  If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty) Then
  

L’exemple suivant utilise la IsNullOrEmpty méthode dans l’implémentation IFormattable.ToString d’une classe personnalisée Temperature . La méthode prend en charge les chaînes de format « G », « C », « F » et « K ». Si une chaîne de format vide ou une chaîne de format dont la valeur est null passée à la méthode, sa valeur est remplacée par la chaîne de format « G ».

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));
   }                                   
}

member _.ToString(format: string, provider: IFormatProvider) =
    let format = 
        if String.IsNullOrEmpty format then "G" else format
    
    let provider: IFormatProvider = 
        if provider = null then CultureInfo.CurrentCulture else provider

    match format.ToUpperInvariant() with
    // Return degrees in Celsius.
    | "G"
    | "C" ->
        temp.ToString("F2", provider) + "°C"
    // Return degrees in Fahrenheit.
    | "F" ->
        (temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
    // Return degrees in Kelvin.
    | "K" ->
        (temp + 273.15).ToString()
    | _ ->
        raise (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 classe StringBuilder

Un String objet est appelé immuable (en lecture seule), car sa valeur ne peut pas être modifiée après sa création. Les méthodes qui semblent modifier un String objet retournent réellement un nouvel String objet qui contient la 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 seule chaîne peuvent entraîner une pénalité significative de performances. Par exemple, le code suivant utilise un générateur de nombres aléatoires pour créer une chaîne avec 1 000 caractères dans la plage 0x0001 pour 0x052F. Bien que le code semble utiliser la concaténation de chaîne pour ajouter un nouveau caractère à la chaîne existante nommée str, il crée en fait un nouvel String objet pour chaque opération de concaténation.

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 += (char)rnd.Next(1, 0x0530);
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()

    let mutable str = String.Empty
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
    for _ = 0 to 1000 do
        str <- str + (rnd.Next(1, 0x0530) |> char |> string)
        if str.Length % 60 = 0 then
            str <- str + Environment.NewLine
    sw.Write str

Imports System.IO
Imports System.Text

Module Example10
    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, &H530))
            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 la String classe pour les opérations qui apportent plusieurs modifications à la valeur d’une chaîne. Contrairement aux instances de la String classe, StringBuilder les objets sont mutables ; lorsque vous concatènez, ajoutez ou supprimez des sous-chaînes d’une chaîne, les opérations sont effectuées sur une seule chaîne. Lorsque vous avez fini de modifier la valeur d’un StringBuilder objet, vous pouvez appeler sa StringBuilder.ToString méthode pour la convertir en chaîne. L’exemple suivant remplace l’utilisé String dans l’exemple précédent pour concaténer 1 000 caractères aléatoires dans la plage pour 0x0001 à 0x052F par un StringBuilder objet.

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((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()
    let sb = StringBuilder()
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)

    for _ = 0 to 1000 do
        sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
        if sb.Length % 60 = 0 then
            sb.AppendLine() |> ignore
    sw.Write(string sb)

Imports System.IO
Imports System.Text

Module Example11
    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, &H530)))
            If sb.Length Mod 60 = 0 Then sb.AppendLine()
        Next
        sw.Write(sb.ToString())
        sw.Close()
    End Sub
End Module

Opérations ordinales et sensibles à la culture

Les membres de la String classe effectuent des opérations ordinales ou culturelles (linguistiques) sur un String objet. Une opération ordinale agit sur la valeur numérique de chaque Char objet. Une opération sensible à la culture agit sur la valeur de l'String objet et prend en compte les règles de casse, de tri, de mise en forme et d’analyse propres à la culture. Les opérations sensibles à la culture s’exécutent dans le contexte d’une culture déclarée explicitement ou de la culture actuelle implicite. Les deux types d’opérations peuvent produire des résultats très différents lorsqu’elles sont effectuées sur la même chaîne.

.NET prend également en charge les opérations de chaîne linguistique non sensibles à la culture à l’aide de la culture invariante (CultureInfo.InvariantCulture), qui est faiblement basée sur les paramètres de culture de la langue anglaise indépendamment de la région. Contrairement à d’autres System.Globalization.CultureInfo paramètres, les paramètres de la culture invariante sont garantis pour rester cohérents sur un seul ordinateur, du système au système et entre les versions de .NET. La culture invariante peut être considérée comme un type de boîte noire qui garantit la stabilité des comparaisons de chaînes et l’ordre dans toutes les cultures.

Les opérations de casse, d’analyse et de mise en forme, de comparaison et de tri, et de vérification de l’égalité peuvent être ordinales ou sensibles à la culture. Les sections suivantes décrivent chaque catégorie d’opération.

Vous pouvez télécharger les tables de pondération de tri, un ensemble de fichiers texte qui contiennent des informations sur les pondérations de caractères utilisées dans les opérations de tri et de comparaison, à partir du tableau d’éléments de classement Unicode par défaut.

Boîtier

Les règles de casse déterminent comment transformer la capitalisation d'un caractère Unicode ; par exemple, passer de minuscules à majuscules. Souvent, une opération de casse est effectuée avant une comparaison de chaînes. Par exemple, une chaîne peut être convertie en majuscules afin qu’elle puisse être comparée à une autre chaîne majuscule. Vous pouvez convertir les caractères d’une chaîne en minuscules en appelant la ou ToLower la ToLowerInvariant méthode, et vous pouvez les convertir en majuscules en appelant la ou ToUpper la ToUpperInvariant méthode. En outre, vous pouvez utiliser la méthode TextInfo.ToTitleCase pour convertir une chaîne en casse de majuscules.

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 invariante. É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. Les différences réelles de casse sont de trois types :

• Différences dans le mappage des cas de LETTRE MAJUSCULE LATINE I (U+0049), LETTRE MINUSCULE LATINE I (U+0069), LETTRE MAJUSCULE LATINE I POINT CI-DESSUS (U+0130) et LETTRE MINUSCULE LATINE SANS POINT I (U+0131). Dans les cultures tr-TR (Turc (Turquie)) et az-Latn-AZ (Azerbaïdjan, Latin), ainsi que dans les cultures neutres tr, az et az-Latn, l’équivalent minuscule de LA LETTRE MAJUSCULE LATINE I est LA LETTRE MINUSCULE LATINE I SANS POINT, et l’équivalent majuscule de LA LETTRE MINUSCULE LATINE I est LA LETTRE MAJUSCULE LATINE I AVEC POINT AU-DESSUS. Dans toutes les autres cultures, y compris la culture invariante, la lettre latine minuscule I et la lettre latine majuscule I sont des équivalents en minuscules et en majuscules.

  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 s’il s’appuie sur une comparaison de casse sensible à la culture. (Les conventions de casse de la culture invariante auraient dû être utilisées.)

  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
  

  open System
  open System.Globalization
  open System.Threading
  
  let disallowed = "file"
  
  let isAccessAllowed (resource: string) =
      let cultures = 
          [| CultureInfo.CreateSpecificCulture "en-US"
             CultureInfo.CreateSpecificCulture "tr-TR" |]
      let index = resource.IndexOfAny [| '\\'; '/' |]
      let scheme =
          if index > 0 then
              resource.Substring(0, index - 1)
          else 
              null
  
      // Change the current culture and perform the comparison.
      for culture in cultures do
          Thread.CurrentThread.CurrentCulture <- culture
          printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
          printfn $"{resource}"
          printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
          printfn ""
          
  isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
  // 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 Example2
      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 dans les mappages de cas entre la culture invariante et toutes les autres cultures. Dans ces cas, l’utilisation des règles de casse de la culture invariante pour modifier un caractère en majuscules ou minuscules renvoie le même caractère. Pour toutes les autres cultures, elle retourne un caractère différent. Certains des caractères affectés sont répertoriés dans le tableau suivant.

  Caractère	Si la modification est apportée à	Returns
  SIGNE MICRO (U+00B5)	Majuscules	LETTRE MAJUSCULE GRECQUE MU (U+-39C)
  LETTRE MAJUSCULE LATINE I AVEC POINT EN DESSUS (U+0130)	Minuscules	LETTRE MINUSCULE LATINE I (U+0069)
  LETTRE MINUSCULE LATINE I SANS POINT (U+0131)	Majuscules	LETTRE MAJUSCULE LATINE I (U+0049)
  LETTRE MINUSCULE LATINE S LONG (U+017F)	Majuscules	LETTRE MAJUSCULE LATINE S (U+0053)
  LETTRE MAJUSCULE LATINE D AVEC LETTRE MINUSCULE Z AVEC CARON (U+01C5)	Minuscules	LETTRE MINUSCULE LATINE DZ AVEC CARON (U+01C6)
  COMBINAISON DE GREC YPOGEGRAMMENI (U+0345)	Majuscules	LETTRE MAJUSCULE GRECQUE IOTA (U+0399)

• Différences dans les mappages de cas de paires de casse mixte à deux lettres dans la plage de caractères ASCII. Dans la plupart des cultures, une paire de deux lettres avec des cases mixtes correspond à la paire de lettres en majuscules ou en minuscules équivalente. Cela n’est pas vrai pour les paires à deux lettres suivantes dans les cultures suivantes, car dans chaque cas, elles sont comparées à un digraphe :

  • « lJ » et « nJ » dans la culture hr-HR (Croatie).
  • « cH » dans les cultures cs-CZ (République tchèque)) et sk-SK (Slovaque (Slovaquie)).
  • « aA » dans la culture da-DK (Danemark)).
  • « cS », « dZ », « dZS », « nY », « sZ », « tY » et « zS » dans la culture hu-HU (Hongrie)).
  • « cH » et « lL » dans la culture es-ES_tradnl (Espagnol (Espagne, Sort traditionnel)).
  • « cH », « gI », « kH », « nG », « nH », « pH », « qU », « tH » et « tR » dans la culture vi-VN (Vietnam).

  Toutefois, il est inhabituel de rencontrer une situation dans laquelle une comparaison sensible à la culture de ces paires crée des problèmes, car ces paires sont rares dans les chaînes fixes ou les identificateurs.

L'exemple suivant illustre certaines des différences de règles de casse typographique entre les paramètres régionaux lors de la conversion de chaînes en majuscules.

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

open System
open System.Globalization
open System.IO

let showHexValue (s: string) =
    let mutable retval = ""
    for ch in s do
        let bytes = BitConverter.GetBytes ch
        retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
    retval

do
    use sw = new StreamWriter(@".\case.txt")
    let words = [| "file"; "sıfır"; "Dženana" |]
    let cultures = 
        [| CultureInfo.InvariantCulture 
           CultureInfo "en-US"
           CultureInfo "tr-TR" |]

    for word in words do
        sw.WriteLine("{0}:", word)
        for culture in cultures do
            let name =
                 if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
            let upperWord = word.ToUpper culture
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
        sw.WriteLine()
    sw.Close()

// 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 Example1
    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 forme

La mise en forme et l’analyse sont des opérations inverses. Les règles de mise en forme déterminent comment convertir une valeur, telle qu’une date et une heure ou un nombre, en sa 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 valeur telle qu’une date et une heure. Les règles de mise en forme et d’analyse dépendent des conventions culturelles. L’exemple suivant illustre l’ambiguïté qui peut survenir lors de l’interprétation d’une chaîne de date spécifique à la culture. 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.

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

open System
open System.Globalization

let date = DateTime(2011, 3, 1)
let cultures = 
      [| CultureInfo.InvariantCulture
         CultureInfo "en-US"
         CultureInfo "fr-FR" |]

for culture in cultures do
    printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {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 Example8
    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 l’illustre l’exemple suivant, une chaîne unique peut produire des dates différentes en fonction de la culture dont les conventions sont utilisées dans l’opération d’analyse.

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

open System
open System.Globalization

let dateString = "07/10/2011"
let cultures = 
    [| CultureInfo.InvariantCulture
       CultureInfo.CreateSpecificCulture "en-GB"
       CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
    let date = DateTime.Parse(dateString, culture)
    printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// 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 Example18
    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 de chaînes et tri

Les conventions de comparaison et de tri des chaînes varient de la culture à la culture. Par exemple, l’ordre de tri peut être basé sur des phonétiques ou sur la représentation visuelle des caractères. Dans les langues d'Asie orientale, les caractères sont classés en fonction du trait et de la clé des idéogrammes. Le tri dépend également de l’ordre des langues et cultures utilisées pour l’alphabet. Par exemple, la langue danoise emploie un caractère "Æ" qu'elle place après "Z" dans l'alphabet. En outre, les comparaisons peuvent être sensibles ou non à la casse, et les règles de casse peuvent différer selon la culture. En revanche, la comparaison ordinale utilise les points de code Unicode de caractères individuels dans une chaîne lors de la comparaison et du tri de chaînes.

Les règles de tri déterminent l’ordre alphabétique des caractères Unicode et la comparaison entre deux chaînes. Par exemple, la String.Compare(String, String, StringComparison) méthode compare deux chaînes en fonction du StringComparison paramètre. Si la valeur du paramètre est StringComparison.CurrentCulture, la méthode effectue une comparaison linguistique qui utilise les conventions de la culture actuelle ; si la valeur du paramètre est StringComparison.Ordinal, la méthode effectue une comparaison ordinale. Par conséquent, comme l’illustre l’exemple suivant, si la culture actuelle est l’anglais américain, le premier appel à la méthode (à l’aide d’une comparaison sensible à la String.Compare(String, String, StringComparison) 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 ».

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

open System
open System.Globalization
open System.Threading

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{String.Compare("A", "a", StringComparison.Ordinal)}"""
// The example displays the following output:
//       1
//       -32

Imports System.Globalization
Imports System.Threading

Module Example3
    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, par chaîne de caractères et par ordre :

• Un tri de chaînes de caractères effectue une comparaison sensible à la culture, dans laquelle certains caractères Unicode non alphanumériques peuvent se voir attribuer des poids spéciaux. Par exemple, le trait d’union (-) peut avoir un poids très faible lui étant attribué afin que « coop » et « coopérative » apparaissent en regard des autres dans une liste triée. Pour obtenir la liste des String méthodes qui comparent deux chaînes à l’aide de règles de tri de mots, consultez la section Opérations de chaîne par catégorie .

• Un tri de chaîne effectue également une comparaison sensible à la culture. Il est similaire à un tri de mots, sauf qu’il n’y a pas de cas spéciaux, et tous les symboles non alphanumériques viennent avant tous les caractères Unicode alphanumériques. Deux chaînes peuvent être comparées à l'aide des règles de tri de chaînes en appelant les surcharges de méthode CompareInfo.Compare qui prennent un paramètre options auquel est attribuée une valeur de 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.

• Un tri ordinal compare les chaînes en fonction de la valeur numérique de chaque Char objet de la chaîne. Une comparaison ordinale respecte automatiquement la casse, car les versions minuscules et majuscules d’un caractère ont des points de code différents. Toutefois, si le cas n’est pas important, vous pouvez spécifier une comparaison ordinale qui ignore la casse. Cela équivaut à convertir la chaîne en majuscules à l’aide de la culture invariante, puis à effectuer une comparaison ordinale sur le résultat. Pour obtenir la liste des String méthodes qui comparent deux chaînes à l’aide de règles de tri ordinales, consultez la section Opérations de chaîne par catégorie .

Une comparaison sensible à la culture est toute comparaison qui utilise explicitement ou implicitement un CultureInfo objet, y compris la culture invariante spécifiée par la CultureInfo.InvariantCulture propriété. La culture implicite est la culture actuelle, qui est spécifiée par les propriétés Thread.CurrentCulture et CultureInfo.CurrentCulture. Il existe des variations considérables dans l’ordre de tri des caractères alphabétiques (c’est-à-dire des caractères pour lesquels la Char.IsLetter méthode retourne true) entre les cultures. Vous pouvez spécifier une comparaison sensible à la culture qui utilise les conventions d’une culture spécifique en fournissant un CultureInfo objet à une méthode de comparaison de chaînes telle que Compare(String, String, CultureInfo, CompareOptions). Vous pouvez spécifier une comparaison sensible à la culture qui utilise les conventions de la culture actuelle en fournissant StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, ou tout membre de l’énumération CompareOptions à l'exception de CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase à une surcharge appropriée de la méthode Compare. Une comparaison sensible à la culture est généralement appropriée pour le tri, alors qu’une comparaison ordinale n’est pas. Une comparaison ordinale est généralement appropriée pour déterminer si deux chaînes sont égales (c’est-à-dire, pour déterminer l’identité), alors qu’une comparaison sensible à la culture n’est pas.

L’exemple suivant illustre la différence entre la comparaison ordinale et sensible à la culture. L'exemple évalue trois chaînes de caractères, « Apple », « Æble » et « AEble », en utilisant la comparaison ordinale et les conventions des cultures da-DK et en-US (chacune étant la culture par défaut au moment où la méthode Compare est appelée). É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 ». Toutefois, « Æble » n’est pas considéré comme équivalent à « AEble », donc « Æble » est également supérieur à « AEble ». La culture en-US n’inclut pas la lettre « Æ », mais la traite comme équivalente à « AE », ce qui explique pourquoi « Æble » est inférieur à « Apple » mais égal à « AEble ». En revanche, la comparaison ordinale considère que « Apple » est inférieur à « Æble » et « Æble » comme supérieur à « 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

open System
open System.Globalization
open System.Threading

let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"

// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {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 Example6
    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 comparaison de chaînes ou de tri appropriée :

• 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. Si la culture de l’utilisateur change, l’ordre des chaînes triées change également en conséquence. Par exemple, une application de dictionnaire des synonymes doit toujours trier les mots en fonction de la culture de l’utilisateur.

• Si vous souhaitez que les chaînes soient ordonnées en fonction des conventions d’une culture spécifique, vous devez les commander en fournissant un CultureInfo objet qui représente cette culture à une méthode de comparaison. Par exemple, dans une application conçue pour enseigner aux étudiants une langue particulière, vous souhaitez que les chaînes soient ordonnées en fonction des conventions de l’une des cultures qui parlent cette langue.

• 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 invariante ou utiliser une comparaison ordinale. Par exemple, vous utilisez un tri ordinal pour organiser les noms de fichiers, de processus, de mutex ou de canaux nommés.

• 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 pour l’égalité en appelant une surcharge de la Equals méthode.

Pour plus d’informations sur les règles de tri word, chaîne et ordinale, consultez la System.Globalization.CompareOptions rubrique. Pour obtenir des recommandations supplémentaires sur l’utilisation de chaque règle, consultez Les meilleures pratiques pour l’utilisation de chaînes.

En règle générale, vous n’appelez pas de méthodes de comparaison de chaînes telles que Compare directement pour déterminer l’ordre de tri des chaînes. Au lieu de cela, les méthodes de comparaison sont appelées par des méthodes de tri telles que Array.Sort ou List<T>.Sort. L’exemple suivant effectue quatre opérations de tri différentes (tri de mots à l’aide de la culture actuelle, tri de mot à l’aide de la culture invariante, tri ordinal et tri de chaîne à l’aide de la culture invariante) sans appeler explicitement une méthode de comparaison de chaînes, bien qu’ils spécifient le type de comparaison à utiliser. Notez que chaque type de tri produit un classement unique de chaînes dans son tableau.

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

open System
open System.Collections.Generic
open System.Globalization

// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare = 
    { new IComparer<String> with
        member _.Compare(x, y) =
            CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }

let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]

// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)

// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)

// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)

// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)

// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
    printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]

// 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 Example4
    Public Sub Main()
        Dim strings() As String = {"coop", "co-op", "cooperative",
                                  "co" + ChrW(&HAD) + "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

Si vous ne spécifiez pas de convention de comparaison de chaînes, les méthodes de tri telles que Array.Sort(Array) effectuent un tri sensible à la culture et à la casse sur les chaînes. L’exemple suivant montre comment la modification de la culture actuelle affecte l’ordre des chaînes triées dans un tableau. Il crée un tableau de trois chaînes. D'abord, cela définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture à en-US, et appelle la méthode Array.Sort(Array). L’ordre de tri résultant est basé sur des conventions de tri pour la culture anglaise (États-Unis). Ensuite, l'exemple définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture sur da-DK et appelle à nouveau la méthode Array.Sort. Observez comment l'ordre de tri résultant diffère des résultats en-US parce qu'il utilise les conventions de tri pour le danois (Danemark).

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

open System
open System.Globalization
open System.Threading

let printIndexAndValues (myArray: string[]) =
    for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
        printfn $"[{i}]: {myArray[i]}" 
    printfn ""

// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]

// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray

// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray

// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// 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

Les méthodes de recherche de chaînes, telles que String.StartsWith et String.IndexOf, peuvent également effectuer des comparaisons de chaînes sensibles à la culture ou ordinales. L’exemple suivant illustre les différences entre les comparaisons ordinales et sensibles à la culture à l’aide de la IndexOf méthode. Une recherche sensible à la culture où la culture actuelle est l'anglais (États-Unis) considère que la sous-chaîne « oe » correspond à la ligature « œ ». Étant donné qu’un trait d’union doux (U+00AD) est un caractère de largeur nulle, la recherche traite le trait d’union doux comme équivalent et String.Empty trouve une correspondance au début de la chaîne. Une recherche ordinale, d’autre part, ne trouve pas de correspondance dans les deux cas.

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

open System

let findInString (s: string) (substring: string) (options: StringComparison) =
    let result = s.IndexOf(substring, options)
    if result <> -1 then
        printfn $"'{substring}' found in {s} at position {result}"
    else
        printfn $"'{substring}' not found in {s}"

// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""

let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal

// 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 Example5
    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(&HAD)
        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 Then
            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 dans des chaînes

Les méthodes de recherche de chaîne, telles que String.StartsWith et String.IndexOf, peuvent également effectuer des comparaisons de chaînes sensibles à la culture ou ordinale pour déterminer si un caractère ou une sous-chaîne est trouvé dans une chaîne spécifiée.

Les méthodes de recherche dans la String classe qui recherchent un caractère individuel, comme la IndexOf méthode, ou l’un d’un ensemble de caractères, comme la IndexOfAny méthode, effectuent toutes une recherche ordinale. Pour effectuer une recherche sensible à la culture d’un caractère, vous devez appeler une méthode CompareInfo telle que CompareInfo.IndexOf(String, Char) ou CompareInfo.LastIndexOf(String, Char). Notez que les résultats de la recherche d’un caractère à l’aide d’une comparaison ordinale et sensible à la culture peuvent être très différents. Par exemple, une recherche d’un caractère Unicode précomposé tel que ligature « Æ » (U+00C6) peut correspondre à n’importe quelle occurrence de ses composants dans la séquence correcte, telle que « AE » (U+041U+0045), en fonction de la culture. L’exemple suivant illustre la différence entre les méthodes String.IndexOf(Char) et CompareInfo.IndexOf(String, Char) pour la recherche d’un caractère individuel. Ligature « æ » (U+00E6) se trouve dans la chaîne "aerial" 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.

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

open System.Globalization

let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ'  // U+00E6

printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
                  
for cultureName in cultureNames do
    let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
    printf $"{cultureName} cultural comparison -- "
    printfn $"Position of '{ch}' in {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 Example19
    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 sensible à la culture si les options de recherche ne sont pas explicitement spécifiées par un paramètre de type StringComparison. La seule exception est Contains, qui effectue une recherche ordinale.

Tester l’égalité

Utilisez la String.Compare méthode pour déterminer la relation de deux chaînes dans l’ordre de tri. En règle générale, il s’agit d’une opération sensible à la culture. En revanche, appelez la String.Equals méthode pour tester l’égalité. Étant donné que le test d’égalité compare généralement l’entrée utilisateur à 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.

L’exemple suivant illustre le danger d’effectuer une comparaison sensible à la culture pour l’égalité lorsqu’un ordinal doit être utilisé à la place. Dans ce cas, l’intention du code est d’interdire l’accès au système de fichiers à partir d’URL commençant par « FILE:// » ou « file:// » en effectuant une comparaison insensible à la casse du début d’une URL avec la chaîne « FILE:// ». Toutefois, si une comparaison sensible à la culture est effectuée à l’aide de la culture turque (Turquie) sur une URL qui commence par « file:// », la comparaison de l’égalité échoue, car l’équivalent en majuscules turcs de la minuscule « i » est « İ » au lieu de « I ». Par conséquent, l’accès au système de fichiers est autorisé par inadvertance. En revanche, si une comparaison ordinale est effectuée, la comparaison de l’égalité réussit et l’accès au système de fichiers est refusé.

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.

open System
open System.Globalization
open System.Threading

let testForEquality (str: string) (cmp: StringComparison) =
    let position = str.IndexOf "://"
    if position < 0 then false
    else
        let substring = str.Substring(0, position)
        substring.Equals("FILE", cmp)

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"

let filePath = "file://c:/notes.txt"

printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

// 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 Example7
    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.

Normalisation

Certains caractères Unicode ont plusieurs représentations. Par exemple, l’un des points de code suivants peut représenter la lettre « ắ » :

• U+1EAF
• U+0103 U+0301
• U+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îne.

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. La normalisation peut utiliser plusieurs algorithmes, appelés formulaires de normalisation, qui suivent différentes règles. .NET prend en charge les formulaires de normalisation Unicode C, D, KC et KD. Lorsque des chaînes ont été normalisées dans le même formulaire de normalisation, elles peuvent être comparées à l’aide de la comparaison ordinale.

Une comparaison ordinale est une comparaison binaire de la valeur scalaire Unicode des objets correspondants Char dans chaque chaîne. La String classe inclut un certain nombre de méthodes qui peuvent effectuer une comparaison ordinale, notamment les suivantes :

• Toute surcharge des méthodes Compare, Equals, StartsWith, EndsWith, IndexOf, et LastIndexOf qui inclut un paramètre StringComparison. La méthode effectue une comparaison ordinale si vous fournissez une valeur de StringComparison.Ordinal ou de OrdinalIgnoreCase pour ce paramètre.

• Les surcharges de la méthode CompareOrdinal

• Méthodes qui utilisent la comparaison ordinale par défaut, telles que Contains, Replaceet Split.

• Méthodes qui cherchent une Char valeur ou les éléments d’un Char tableau dans une instance de chaîne de caractères. Ces méthodes incluent IndexOf(Char) et Split(Char[]).

Vous pouvez déterminer si une chaîne est normalisée au 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 dans un formulaire de normalisation spécifié. 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 formulaire de normalisation spécifié. Pour obtenir des informations pas à pas sur la normalisation et la comparaison des chaînes, consultez les méthodes Normalize() et Normalize(NormalizationForm).

L’exemple simple suivant illustre la normalisation des chaînes. Il définit la lettre « ố » de trois façons différentes dans trois chaînes différentes et utilise une comparaison ordinale pour l’égalité pour déterminer que chaque chaîne diffère des deux autres chaînes. Il convertit ensuite chaque chaîne en formulaires de normalisation pris en charge, puis effectue une comparaison ordinale de chaque chaîne dans un formulaire de normalisation spécifié. Dans chaque cas, le deuxième test d’égalité indique que les chaînes sont égales.

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 += $"{(ushort)ch: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

open System
open System.IO
open System.Text

do
    use sw = new StreamWriter(@".\TestNorm1.txt")

    let showBytes (str: string) =
        let mutable result = ""
        for ch in str do
            result <- result + $"{uint16 ch:X4} "
        result.Trim()
    
    let testForEquality (words: string[]) =
        for ctr = 0 to words.Length - 2 do
            for ctr2 = ctr + 1 to words.Length - 1 do
                sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                            words[ctr], showBytes(words[ctr]),
                            words[ctr2], showBytes(words[ctr2]),
                            words[ctr].Equals(words[ctr2], StringComparison.Ordinal))

    let normalizeStrings nf (words: string[]) =
        for i = 0 to words.Length - 1 do
            if not (words[i].IsNormalized nf) then
                words[i] <- words[i].Normalize nf
        words

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

    testForEquality [| s1; s2; s3 |]
    sw.WriteLine()

    // Normalize and compare strings using each normalization form.
    for formName in Enum.GetNames typeof<NormalizationForm> do
        sw.WriteLine("Normalization {0}:\n", formName)
        let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
        let sn = normalizeStrings nf [| s1; s2; s3|]
        testForEquality sn
        sw.WriteLine "\n"

// 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 Example16
    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(&HF4) + ChrW(&H301) + "ng"
        Dim s3 As String = "so" + ChrW(&H302) + ChrW(&H301) + "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 la normalisation et les formulaires de normalisation, consultez System.Text.NormalizationForm, ainsi que l’annexe standard Unicode #15 : Formulaires de normalisation Unicode et le FORUM aux questions sur la normalisation sur le site web unicode.org.

Opérations de chaîne par catégorie

La String classe fournit des membres pour comparer des chaînes, tester des chaînes pour l’égalité, rechercher des caractères ou des sous-chaînes dans une chaîne, modifier une chaîne, extraire des sous-chaînes d’une chaîne, combiner des chaînes, mettre en forme des valeurs, copier une chaîne et normaliser une chaîne.

Comparer des chaînes

Vous pouvez comparer des chaînes pour déterminer leur position relative dans l’ordre de tri à l’aide des méthodes suivantes String :

• Compare retourne un entier qui indique la relation d’une chaîne à une deuxième chaîne dans l’ordre de tri.

• CompareOrdinal retourne un entier qui indique la relation d’une chaîne à une deuxième chaîne en fonction d’une comparaison de leurs points de code.

• CompareTo retourne un entier qui indique la relation de l’instance de chaîne actuelle à une deuxième chaîne dans l’ordre de tri. La méthode CompareTo(String) fournit les implémentations IComparable et IComparable<T> pour la classe String.

Tester l’égalité de chaînes de caractères

Vous appelez la Equals méthode pour déterminer si deux chaînes sont égales. L'instance Equals(String, String, StringComparison) et les surcharges statiques Equals(String, StringComparison) vous permettent de spécifier si la comparaison est sensible à la culture ou ordinale, et si la casse est prise en compte ou ignorée. La plupart des tests d’égalité sont ordinals et les comparaisons pour l’égalité qui déterminent l’accès à une ressource système (par exemple, un objet de système de fichiers) doivent toujours être ordinales.

Rechercher des caractères dans une chaîne

La String classe comprend deux types de méthodes de recherche :

• Méthodes qui retournent une Boolean valeur pour indiquer si une sous-chaîne particulière est présente dans une instance de chaîne. Il s’agit notamment des méthodes Contains, EndsWith et StartsWith.

• Méthodes qui indiquent la position de départ d’une sous-chaîne dans une instance de chaîne. Il s'agit notamment des méthodes IndexOf, IndexOfAny, LastIndexOf et LastIndexOfAny.

Modifier une chaîne

La String classe inclut les méthodes suivantes qui semblent modifier la valeur d’une chaîne :

• Insert insère une chaîne dans l’instance actuelle String .

• PadLeft insère une ou plusieurs occurrences d’un caractère spécifié au début d’une chaîne.

• PadRight insère une ou plusieurs occurrences d’un caractère spécifié à la fin d’une chaîne.

• Remove supprime une sous-chaîne de l’instance actuelle String .

• Replace remplace une sous-chaîne par une autre sous-chaîne dans l’instance actuelle String .

• ToLower et ToLowerInvariant convertir tous les caractères d’une chaîne en minuscules.

• ToUpper et ToUpperInvariant convertir tous les caractères d’une chaîne en majuscules.

• Trim supprime toutes les occurrences d’un caractère du début et de la fin d’une chaîne.

• TrimEnd supprime toutes les occurrences d’un caractère de la fin d’une chaîne.

• TrimStart supprime toutes les occurrences d’un caractère au début d’une chaîne.

Extraire des sous-chaînes d’une chaîne

La String.Split méthode sépare une seule chaîne en plusieurs chaînes. Les surcharges de la méthode vous permettent de spécifier plusieurs délimiteurs, de limiter le nombre de sous-chaînes extraites par la méthode, de réduire l’espace blanc des sous-chaînes et de spécifier si des chaînes vides (qui se produisent lorsque des délimiteurs sont adjacents) sont incluses dans les chaînes retournées.

Combiner des chaînes

Les méthodes suivantes String peuvent être utilisées pour la concaténation de chaînes :

• Concat combine une ou plusieurs sous-chaînes en une seule chaîne.
• Join concatène une ou plusieurs sous-chaînes en un seul élément et ajoute un séparateur entre chaque sous-chaîne.

Mettre en forme les valeurs

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. La Format méthode est souvent utilisée pour effectuer les opérations suivantes :

• Pour incorporer la représentation sous forme de chaîne d’une valeur numérique dans une chaîne.
• Pour incorporer la représentation sous forme de chaîne d’une valeur de date et d’heure dans une chaîne.
• Pour incorporer la représentation sous forme de chaîne d’une valeur d’énumération dans une chaîne.
• Pour incorporer la représentation sous forme de chaîne d’un objet qui prend en charge l’interface IFormattable dans une chaîne.
• Pour justifier à droite ou à gauche une sous-chaîne dans un champ d'une chaîne plus grande.

Pour plus d’informations sur les opérations de mise en forme et les exemples, consultez le résumé du surchargement Format.

Copier une chaîne

Vous pouvez appeler les méthodes suivantes String pour effectuer une copie d’une chaîne :

• Clone retourne une référence à un objet existant String .
• CopyTo copie une partie d’une chaîne dans un tableau de caractères.

Normaliser une chaîne

En Unicode, un caractère unique peut avoir plusieurs points de code. La normalisation convertit ces caractères équivalents en la même représentation binaire. La String.Normalize méthode effectue la normalisation et la String.IsNormalized méthode détermine si une chaîne est normalisée.

Pour plus d’informations et un exemple, consultez la section Normalisation plus haut dans cet article.

Cohérence de thread

Ce type est thread safe.

Voir aussi

• IComparable
• ICloneable
• IConvertible
• IEnumerable
• StringBuilder
• CultureInfo
• Tables d’éléments de classement Unicode par défaut
• Types de mise en forme dans .NET
• Bonnes pratiques pour l’utilisation de chaînes dans .NET