Partager via

Indexation de chaîne

  • Article

La classe System.Globalization.StringInfo fournit des méthodes qui vous permettent de décomposer une chaîne en éléments de texte et d'itérer au sein de ces éléments. Un élément de texte est une unité de texte qui est affichée sous la forme d'un seul caractère, appelé graphème. Un élément de texte peut être un caractère de base, une paire de substitution ou une séquence de caractères d'association. Pour plus d'informations sur les paires de substitution et les séquences de caractères d'association, consultez Prise en charge Unicode pour les paires de substitution et les séquences de caractères d'association.

Utilisez la méthode StringInfo.GetTextElementEnumerator afin de créer un énumérateur qui peut être utilisé pour itérer au sein des éléments de la chaîne. D'autre part, la méthode StringInfo.ParseCombiningCharacters vous permet de retourner les index de chaque caractère de base, substitut étendu ou caractère de contrôle dans une chaîne spécifiée.

L'exemple de code suivant crée une chaîne de caractères arabes contenant des séquences de caractères d'association. Dans strCombining, par exemple, le code Unicode U+0625 représente un caractère de base arabe (lettre arabe alif hamza souscrit), et le code Unicode U+0650 représente un caractère d'association arabe (kasra arabe). Ensemble, ces codes représentent une séquence de caractères d'association et, de ce fait, doivent être analysés comme un seul élément de texte. Ensuite, l'exemple crée une chaîne contenant des paires de substitution. Dans strSurrogates, par exemple, le code Unicode U+DACE représente un substitut étendu, et le code Unicode U+DEFF représente un substitut faible. Ensemble, ces codes représentent une paire de substitution et, de ce fait, doivent être analysés comme un seul élément de texte. Chaque chaîne est analysée d'abord avec la méthode ParseCombiningCharacters, puis avec la méthode GetTextElementEnumerator. Ces deux méthodes analysent correctement les éléments de type texte dans strCombining aux index 0, 2, 3, 5 et 6. Ces deux méthodes analysent correctement les éléments de type texte dans strSurrogates aux index 0, 2, 4, 5 et 6. Les résultats des opérations d'analyse sont affichés.

Imports System
Imports System.IO
Imports System.Globalization
Imports System.Text
Imports Microsoft.VisualBasic

Public Class StringInfoSample

   Public Shared Sub Main()
      ' Creates a string with text elements at <0;2;3;5;6>.
      ' The Unicode code points specify Arabic 
      ' combining character sequences.
      Dim strCombining As String = ChrW(&H625) & ChrW(&H650) & _
         ChrW(&H64A) & ChrW(&H647) & ChrW(&H64E) & ChrW(&H627) & _
         ChrW(&H628) & ChrW(&H64C)

      ' Creates a string with text elements at <0;2;4;5;6>.
      'The Unicode code points specify private surrogate pairs.
      Dim strSurrogates As String = ChrW(&HDACE) & ChrW(&HDEFF) & _
         ChrW(&HDAAF) & ChrW(&HDEFC) & "a" & ChrW(&HD8BF) & ChrW(&HDD99)
      
      EnumerateTextElements(strCombining)
      EnumerateTextElements(strSurrogates)
   End Sub

   Public Shared Sub EnumerateTextElements(str As String)
      ' Creates a TextElementEnumerator.
      Dim TEIndices As Integer() = Nothing
      Dim TEEnum As TextElementEnumerator = Nothing      

      ' Parses the string using the ParseCombiningCharacters() method.
      Console.WriteLine(ControlChars.Newline + "Parsing '{0}' Using _
         ParseCombiningCharacters()...", str)
      Dim i As Integer
      TEIndices = StringInfo.ParseCombiningCharacters(str)
      For i = 0 To (TEIndices.Length - 1) - 1
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, _
            TEIndices(i), TEIndices((i + 1)) - 1, _
            str.Substring(TEIndices(i), TEIndices((i + 1)) - _
            TEIndices(i)))
      Next i
      Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, _
         TEIndices(i), str.Length - 1, str.Substring(TEIndices(i)))

      ' Parses the string using the GetTextElementEnumerator method.
      Console.WriteLine(ControlChars.Newline + "Parsing '{0}' Using _
         TextElementEnumerator...", str)
      TEEnum = StringInfo.GetTextElementEnumerator(str)

      Dim Continue As Boolean = False
      Dim TECount As Integer = - 1

      ' Note: Begins at element -1 (none).
      Continue = TEEnum.MoveNext()
      While Continue
         ' 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, TEEnum.Current)

         ' Moves to the next element.
         Continue = TEEnum.MoveNext()
      End While
   End Sub
End Class

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

public class StringInfoSample
{
   public static void Main()
   {
      // Creates a string with text elements at <0;2;3;5;6>.
      // The Unicode code points specify Arabic 
      // combining character sequences.
      string strCombining =   
            "\u0625\u0650\u064A\u0647\u064E\u0627\u0628\u064C";
      // Creates a string with text elements at <0;2;4;5;6>.
      // The Unicode code points specify private surrogate pairs.
      string strSurrogates = "\uDACE\uDEFF\uDAAF\uDEFCa\uD8BF\uDD99"; 

      EnumerateTextElements(strCombining);
      EnumerateTextElements(strSurrogates);
   }

   public static void EnumerateTextElements(string str)
   {
      // Creates a TextElementEnumerator.
      int[] TEIndices = null;
      TextElementEnumerator TEEnum = null;

      // Parses the string using the ParseCombiningCharacters() method.
      Console.WriteLine
         ("\r\nParsing '{0}' Using ParseCombiningCharacters()...",str);
      int i;
      TEIndices = StringInfo.ParseCombiningCharacters(str);
      for (i = 0; i < (TEIndices.Length - 1); i++)
      {
         Console.WriteLine
            ("Text Element {0} ({1}..{2})= 
            {3}",i,TEIndices[i],TEIndices[i+1] - 1,
            str.Substring(TEIndices[i],TEIndices[i+1] - TEIndices[i]));
      }
      Console.WriteLine
         ("Text Element {0} ({1}..{2})= {3}",i,TEIndices[i],str.Length - 
         1, str.Substring(TEIndices[i]));

      // Parses the string using the GetTextElementEnumerator method.
      Console.WriteLine
         ("\r\nParsing '{0}' Using TextElementEnumerator...",str);
      TEEnum = StringInfo.GetTextElementEnumerator(str);

      bool Continue = false;
      int TECount = -1;

      // Note: Begins at element -1 (none).
      Continue = TEEnum.MoveNext();
      while (Continue)
      {
         // Prints 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, 
               TEEnum.Current);

         // Moves to the next element.
         Continue = TEEnum.MoveNext();
         }
   }
}
RemarqueRemarque

Si vous exécutez ce code dans une application console, les éléments de texte Unicode spécifiés ne s'afficheront pas correctement parce que l'environnement console ne prend pas en charge tous les caractères Unicode.

Voir aussi

Référence

StringInfo

Concepts

Unicode dans le .NET Framework

Autres ressources

Encodage et localisation