StringInfo Classe

Définition

Espace de noms:

System.Globalization

Assembly:

System.Runtime.dll

Source:

StringInfo.cs

Fournit des fonctionnalités permettant de fractionner une chaîne en éléments de texte et de parcourir ces éléments de texte.

public ref class StringInfo

public class StringInfo

type StringInfo = class

Public Class StringInfo

Héritage

Object

StringInfo

Exemples

Cet exemple utilise les GetTextElementEnumerator méthodes et ParseCombiningCharacters de la StringInfo classe pour manipuler une chaîne qui contient des caractères de substitution et de combinaison.

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


// Show how to enumerate each real character (honoring surrogates)
// in a string.

void EnumTextElements(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the enumerator returned from GetTextElementEnumerator
    // method to examine each real character.
    TextElementEnumerator^ charEnum =
        StringInfo::GetTextElementEnumerator(combiningChars);
    while (charEnum->MoveNext())
    {
        sb->AppendFormat("Character at index {0} is '{1}'{2}", 
            charEnum->ElementIndex, charEnum->GetTextElement(), 
            Environment::NewLine);
    }

    // Show the results.
    Console::WriteLine("Result of GetTextElementEnumerator:");
    Console::WriteLine(sb);
}


// Show how to discover the index of each real character
// (honoring surrogates) in a string.

void EnumTextElementIndexes(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the ParseCombiningCharacters method to
    // get the index of each real character in the string.
    array <int>^ textElemIndex =
        StringInfo::ParseCombiningCharacters(combiningChars);

    // Iterate through each real character showing the character
    // and the index where it was found.
    for (int i = 0; i < textElemIndex->Length; i++)
    {
        sb->AppendFormat("Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment::NewLine);
    }

    // Show the results.
    Console::WriteLine("Result of ParseCombiningCharacters:");
    Console::WriteLine(sb);
}

int main()
{

    // The string below contains combining characters.
    String^ combiningChars = L"a\u0304\u0308bc\u0327";

    // Show each 'character' in the string.
    EnumTextElements(combiningChars);

    // Show the index in the string where each 'character' starts.
    EnumTextElementIndexes(combiningChars);

};

// This code produces the following output.
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'a-"'
// Character at index 3 is 'b'
// Character at index 4 is 'c,'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4

using System;
using System.Text;
using System.Globalization;

public sealed class App {
   static void Main() {
      // The string below contains combining characters.
      String s = "a\u0304\u0308bc\u0327";

      // Show each 'character' in the string.
      EnumTextElements(s);

      // Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s);
   }

   // Show how to enumerate each real character (honoring surrogates) in a string.
   static void EnumTextElements(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the enumerator returned from GetTextElementEnumerator
      // method to examine each real character.
      TextElementEnumerator charEnum = StringInfo.GetTextElementEnumerator(s);
      while (charEnum.MoveNext()) {
         sb.AppendFormat(
           "Character at index {0} is '{1}'{2}",
           charEnum.ElementIndex, charEnum.GetTextElement(),
           Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:");
      Console.WriteLine(sb);
   }

   // Show how to discover the index of each real character (honoring surrogates) in a string.
   static void EnumTextElementIndexes(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the ParseCombiningCharacters method to
      // get the index of each real character in the string.
      Int32[] textElemIndex = StringInfo.ParseCombiningCharacters(s);

      // Iterate through each real character showing the character and the index where it was found.
      for (Int32 i = 0; i < textElemIndex.Length; i++) {
         sb.AppendFormat(
            "Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:");
      Console.WriteLine(sb);
   }
}

// This code produces the following output:
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'ā̈'
// Character at index 3 is 'b'
// Character at index 4 is 'ç'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4

Imports System.Text
Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' The string below contains combining characters.
      Dim s As String = "a" + ChrW(&h0304) + ChrW(&h0308) + "bc" + ChrW(&h0327)

      ' Show each 'character' in the string.
      EnumTextElements(s)

      ' Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s)
   End Sub

   ' Show how to enumerate each real character (honoring surrogates) in a string.
   Sub EnumTextElements(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

      ' Use the enumerator returned from GetTextElementEnumerator 
      ' method to examine each real character.
      Dim charEnum As TextElementEnumerator = StringInfo.GetTextElementEnumerator(s)
      Do While charEnum.MoveNext()
         sb.AppendFormat("Character at index {0} is '{1}'{2}",
                         charEnum.ElementIndex, 
                         charEnum.GetTextElement(),
                         Environment.NewLine)
      Loop

      ' Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:")
      Console.WriteLine(sb)
   End Sub

   ' Show how to discover the index of each real character (honoring surrogates) in a string.
   Sub EnumTextElementIndexes(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

      ' Use the ParseCombiningCharacters method to 
      ' get the index of each real character in the string.
      Dim textElemIndex() As Integer = StringInfo.ParseCombiningCharacters(s)

      ' Iterate through each real character showing the character and the index where it was found.
      For i As Int32 = 0 To textElemIndex.Length - 1
         sb.AppendFormat("Character {0} starts at index {1}{2}",
                         i, textElemIndex(i), Environment.NewLine)
      Next

      ' Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:")
      Console.WriteLine(sb)
   End Sub
End Module
' The example displays the following output:
'
'       Result of GetTextElementEnumerator:
'       Character at index 0 is 'ā̈'
'       Character at index 3 is 'b'
'       Character at index 4 is 'ç'
'       
'       Result of ParseCombiningCharacters:
'       Character 0 starts at index 0
'       Character 1 starts at index 3
'       Character 2 starts at index 4

Remarques

.NET définit un élément de texte comme une unité de texte qui s’affiche sous la forme d’un caractère unique, c’est-à-dire d’un graphème. Un élément de texte peut être un caractère de base, une paire de substituts ou une séquence de caractères combinant. La norme Unicode définit une paire de substitution comme une représentation codée d’un caractère abstrait unique qui se compose d’une séquence de deux unités de code, où la première unité de la paire est un substitut élevé et la seconde est une substitution faible. La norme Unicode définit une séquence de caractères combinant un caractère de base et un ou plusieurs caractères de combinaison. Une paire de substitution peut représenter un caractère de base ou un caractère de combinaison.

La StringInfo classe vous permet d’utiliser une chaîne sous la forme d’une série d’éléments textuels plutôt que d’objets individuels Char .

Pour instancier un StringInfo objet qui représente une chaîne spécifiée, vous pouvez effectuer l’une des opérations suivantes :

• Appelez le StringInfo(String) constructeur et transmettez-lui la chaîne que l’objet StringInfo doit représenter en tant qu’argument.

• Appelez le constructeur par défaut StringInfo() et affectez la chaîne que l’objet StringInfo doit représenter à la String propriété .

Vous pouvez utiliser les éléments de texte individuels dans une chaîne de deux manières :

• En énumérant chaque élément de texte. Pour ce faire, vous appelez la GetTextElementEnumerator méthode, puis appelez à plusieurs reprises la méthode sur l’objet MoveNext retourné TextElementEnumerator jusqu’à ce que la méthode retourne false.

• En appelant la ParseCombiningCharacters méthode pour récupérer un tableau qui contient l’index de départ de chaque élément de texte. Vous pouvez ensuite récupérer des éléments de texte individuels en passant ces index à la SubstringByTextElements méthode .

L’exemple suivant illustre les deux façons d’utiliser les éléments de texte d’une chaîne. Il crée deux chaînes :

• strCombining, qui est une chaîne de caractères arabes qui comprend trois éléments de texte avec plusieurs Char objets. Le premier élément de texte est le caractère de base ARABIC LETTER ALEF (U+0627) suivi de ARABIC HAMZA BELOW (U+0655) et ARABIC KASRA (U+0650). Le deuxième élément de texte est LETTRE ARABE HEH (U+0647) suivie de LA FATHA ARABE (U+064E). Le troisième élément de texte est LA LETTRE ARABE BEH (U+0628) suivie de l’ARABE DAMMATAN (U+064C).

• strSurrogates, qui est une chaîne qui comprend trois paires de substitution : GREEK ACROPHONIC FIVE TALENTS (U+10148) à partir du plan multilingue supplémentaire, U+20026 à partir du plan ideographique supplémentaire et U+F1001 à partir de l’espace utilisateur privé. L’encodage UTF-16 de chaque caractère est une paire de substitution qui se compose d’un substitut élevé suivi d’un substitut faible.

Chaque chaîne est analysée une fois par la ParseCombiningCharacters méthode, puis par la GetTextElementEnumerator méthode . Les deux méthodes analysent correctement les éléments de texte dans les deux chaînes et affichent les résultats de l’opération d’analyse.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // The Unicode code points specify Arabic base characters and
      // combining character sequences.
      string strCombining = "\u0627\u0655\u0650\u064A\u0647\u064E" +
                            "\u0627\u0628\u064C";

      // The Unicode code points specify private surrogate pairs.
      string strSurrogates = Char.ConvertFromUtf32(0x10148) +
                             Char.ConvertFromUtf32(0x20026) + "a" +
                             Char.ConvertFromUtf32(0xF1001);

      EnumerateTextElements(strCombining);
      EnumerateTextElements(strSurrogates);
   }

   public static void EnumerateTextElements(string str)
   {
      // Get the Enumerator.
      TextElementEnumerator teEnum = null;

      // Parse the string using the ParseCombiningCharacters method.
      Console.WriteLine("\nParsing with ParseCombiningCharacters:");
      int[] teIndices = StringInfo.ParseCombiningCharacters(str);

      for (int i = 0; i < teIndices.Length; i++) {
         if (i < teIndices.Length - 1)
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i,
               teIndices[i], teIndices[i + 1] - 1,
               ShowHexValues(str.Substring(teIndices[i], teIndices[i + 1] -
                             teIndices[i])));
         else
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i,
               teIndices[i], str.Length - 1,
               ShowHexValues(str.Substring(teIndices[i])));
      }
      Console.WriteLine();

      // Parse the string with the GetTextElementEnumerator method.
      Console.WriteLine("Parsing with TextElementEnumerator:");
      teEnum = StringInfo.GetTextElementEnumerator(str);

      int teCount = - 1;

      while (teEnum.MoveNext()) {
         // Displays the current element.
         // Both GetTextElement() and Current retrieve the current
         // text element. The latter returns it as an Object.
         teCount++;
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", teCount,
            teEnum.ElementIndex, teEnum.ElementIndex +
            teEnum.GetTextElement().Length - 1, ShowHexValues((string)(teEnum.Current)));
      }
   }

   private static string ShowHexValues(string s)
   {
      string hexString = "";
      foreach (var ch in s)
         hexString += $"{(ushort)ch:X4} ";

      return hexString;
   }
}
// The example displays the following output:
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01
//
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01

Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' The Unicode code points specify Arabic base characters and 
      ' combining character sequences.
      Dim strCombining As String = ChrW(&H627) & ChrW(&h0655) + ChrW(&H650) & 
              ChrW(&H64A) & ChrW(&H647) & ChrW(&H64E) & ChrW(&H627) & 
              ChrW(&H628) & ChrW(&H64C)

      ' The Unicode code points specify private surrogate pairs.
      Dim strSurrogates As String = Char.ConvertFromUtf32(&h10148) +
                                    Char.ConvertFromUtf32(&h20026) + "a" +
                                    Char.ConvertFromUtf32(&hF1001)
      
      EnumerateTextElements(strCombining)
      EnumerateTextElements(strSurrogates)
   End Sub

   Public Sub EnumerateTextElements(str As String)
      ' Get the Enumerator.
      Dim teEnum As TextElementEnumerator = Nothing      

      ' Parse the string using the ParseCombiningCharacters method.
      Console.WriteLine()
      Console.WriteLine("Parsing with ParseCombiningCharacters:")
      Dim teIndices As Integer() = StringInfo.ParseCombiningCharacters(str)
      
      For i As Integer = 0 To teIndices.Length - 1
         If i < teIndices.Length - 1 Then
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               TEIndices(i), TEIndices((i + 1)) - 1, 
               ShowHexValues(str.Substring(TEIndices(i), TEIndices((i + 1)) - 
                             teIndices(i))))
         Else
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               teIndices(i), str.Length - 1, 
               ShowHexValues(str.Substring(teIndices(i))))
         End If
      Next
      Console.WriteLine()

      ' Parse the string with the GetTextElementEnumerator method.
      Console.WriteLine("Parsing with TextElementEnumerator:")
      teEnum = StringInfo.GetTextElementEnumerator(str)

      Dim TECount As Integer = - 1

      While teEnum.MoveNext()
         ' Prints the current element.
         ' Both GetTextElement() and Current retrieve the current
         ' text element. The latter returns it as an Object.
         TECount += 1
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", teCount, 
            teEnum.ElementIndex, teEnum.ElementIndex + 
            teEnum.GetTextElement().Length - 1, ShowHexValues(CStr(teEnum.Current)))
      End While
   End Sub
   
   Private Function ShowHexValues(s As String) As String
      Dim hexString As String = ""
      For Each ch In s
         hexString += String.Format("{0:X4} ", Convert.ToUInt16(ch))
      Next
      Return hexString
   End Function
End Module
' The example displays the following output:
'       Parsing with ParseCombiningCharacters:
'       Text Element 0 (0..2)= 0627 0655 0650
'       Text Element 1 (3..3)= 064A
'       Text Element 2 (4..5)= 0647 064E
'       Text Element 3 (6..6)= 0627
'       Text Element 4 (7..8)= 0628 064C
'       
'       Parsing with TextElementEnumerator:
'       Text Element 0 (0..2)= 0627 0655 0650
'       Text Element 1 (3..3)= 064A
'       Text Element 2 (4..5)= 0647 064E
'       Text Element 3 (6..6)= 0627
'       Text Element 4 (7..8)= 0628 064C
'       
'       Parsing with ParseCombiningCharacters:
'       Text Element 0 (0..1)= D800 DD48
'       Text Element 1 (2..3)= D840 DC26
'       Text Element 2 (4..4)= 0061
'       Text Element 3 (5..6)= DB84 DC01
'       
'       Parsing with TextElementEnumerator:
'       Text Element 0 (0..1)= D800 DD48
'       Text Element 1 (2..3)= D840 DC26
'       Text Element 2 (4..4)= 0061
'       Text Element 3 (5..6)= DB84 DC01

Notes pour les appelants

En interne, les méthodes de la StringInfo classe appellent les méthodes de la classe pour déterminer les CharUnicodeInfo catégories de caractères. À compter de .NET Framework 4.6.2, la classification des caractères est basée sur la norme Unicode, version 8.0.0. Pour .NET Framework 4 à .NET Framework 4.6.1, il est basé sur la version 6.3.0 de La norme Unicode. Dans .NET Core, il est basé sur Unicode Standard, version 8.0.0.

Constructeurs

StringInfo()	Initialise une nouvelle instance de la classe StringInfo.
StringInfo(String)	Initialise une nouvelle instance de la classe StringInfo dans une chaîne spécifiée.

Propriétés

LengthInTextElements	Obtient le nombre d’éléments de texte dans l’objet StringInfo actuel.
String	Obtient ou définit la valeur de l’objet StringInfo actuel.

Méthodes

Equals(Object)	Indique si l'objet StringInfo en cours est égal à un objet spécifié.
GetHashCode()	Calcule un code de hachage pour la valeur de l'objet StringInfo en cours.
GetNextTextElement(String)	Obtient le premier élément de texte dans une chaîne spécifiée.
GetNextTextElement(String, Int32)	Obtient l'élément de texte à l'index spécifié de la chaîne spécifiée.
GetNextTextElementLength(ReadOnlySpan<Char>)	Retourne la longueur du premier élément de texte (cluster graphème étendu) qui se produit dans l’étendue d’entrée.
GetNextTextElementLength(String)	Retourne la longueur du premier élément de texte (cluster graphème étendu) qui se produit dans la chaîne d’entrée.
GetNextTextElementLength(String, Int32)	Retourne la longueur du premier élément de texte (cluster graphème étendu) qui se produit dans la chaîne d’entrée à partir de l’index spécifié.
GetTextElementEnumerator(String)	Retourne un énumérateur qui itère au sein des éléments de texte de l'ensemble de la chaîne.
GetTextElementEnumerator(String, Int32)	Retourne un énumérateur qui itère au sein des éléments de texte de la chaîne, en commençant à l'index spécifié.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ParseCombiningCharacters(String)	Retourne les index de tous les caractères de base, substituts étendus ou caractères de contrôle dans la chaîne spécifiée.
SubstringByTextElements(Int32)	Récupère une sous-chaîne d'éléments de texte à partir de l'objet StringInfo en cours, commençant à un élément de texte spécifié et continuant jusqu'au dernier élément de texte.
SubstringByTextElements(Int32, Int32)	Récupère une sous-chaîne d'éléments de texte à partir de l'objet StringInfo en cours, commençant à un élément de texte spécifié et continuant pour le nombre spécifié d'éléments de texte.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

• Tri des tables de pondération pour les systèmes d’exploitation Windows
• Table d’éléments de classement Unicode par défaut, pour Linux et macOS