TextElementEnumerator Classe

Définition

public ref class TextElementEnumerator : System::Collections::IEnumerator

public class TextElementEnumerator : System.Collections.IEnumerator

[System.Serializable]
public class TextElementEnumerator : System.Collections.IEnumerator

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class TextElementEnumerator : System.Collections.IEnumerator

type TextElementEnumerator = class
    interface IEnumerator

[<System.Serializable>]
type TextElementEnumerator = class
    interface IEnumerator

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TextElementEnumerator = class
    interface IEnumerator

Public Class TextElementEnumerator
Implements IEnumerator

Héritage

Object

TextElementEnumerator

Attributs

SerializableAttribute ComVisibleAttribute

Implémente

IEnumerator

Exemples

L’exemple suivant utilise la TextElementEnumerator classe pour énumérer les éléments de texte d’une chaîne.

using namespace System;
using namespace System::Globalization;
int main()
{

   // Creates and initializes a String containing the following:
   //   - a surrogate pair (high surrogate U+D800 and low surrogate U+DC00)
   //   - a combining character sequence (the Latin small letter S"a" followed by the combining grave accent)
   //   - a base character (the ligature S"")
   String^ myString = L"\xD800\xDC00"
   L"a\u0300\u00C6";

   // Creates and initializes a TextElementEnumerator for myString.
   TextElementEnumerator^ myTEE = StringInfo::GetTextElementEnumerator( myString );

   // Displays the values returned by ElementIndex, Current and GetTextElement.
   // Current and GetTextElement return a String* containing the entire text element.
   Console::WriteLine( "Index\tCurrent\tGetTextElement" );
   myTEE->Reset();
   while ( myTEE->MoveNext() )
      Console::WriteLine( "[{0}]:\t {1}\t {2}", myTEE->ElementIndex, myTEE->Current, myTEE->GetTextElement() );
}

/*
This code produces the following output.  The question marks take the place of high and low surrogates.

Index   Current GetTextElement
[0]:    𐀀       𐀀
[2]:    à       à
[4]:    Æ       Æ

*/

using System;
using System.Globalization;

public class SamplesTextElementEnumerator  {

   public static void Main()  {

      // Creates and initializes a String containing the following:
      //   - a surrogate pair (high surrogate U+D800 and low surrogate U+DC00)
      //   - a combining character sequence (the Latin small letter "a" followed by the combining grave accent)
      //   - a base character (the ligature "")
      String myString = "\uD800\uDC00\u0061\u0300\u00C6";

      // Creates and initializes a TextElementEnumerator for myString.
      TextElementEnumerator myTEE = StringInfo.GetTextElementEnumerator( myString );

      // Displays the values returned by ElementIndex, Current and GetTextElement.
      // Current and GetTextElement return a string containing the entire text element.
      Console.WriteLine( "Index\tCurrent\tGetTextElement" );
      myTEE.Reset();
      while (myTEE.MoveNext())  {
         Console.WriteLine( "[{0}]:\t{1}\t{2}", myTEE.ElementIndex, myTEE.Current, myTEE.GetTextElement() );
      }
   }
}

/*
This code produces the following output.  The question marks take the place of high and low surrogates.

Index   Current GetTextElement
[0]:    𐀀       𐀀
[2]:    à       à
[4]:    Æ       Æ

*/

Imports System.Globalization

Public Class SamplesTextElementEnumerator

   Public Shared Sub Main()

      ' Creates and initializes a String containing the following:
      '   - a surrogate pair (high surrogate U+D800 and low surrogate U+DC00)
      '   - a combining character sequence (the Latin small letter "a" followed by the combining grave accent)
      '   - a base character (the ligature "")
      Dim myString As String = ChrW(&HD800) & ChrW(&HDC00) & ChrW(&H0061) & ChrW(&H0300) & ChrW(&H00C6)

      ' Creates and initializes a TextElementEnumerator for myString.
      Dim myTEE As TextElementEnumerator = StringInfo.GetTextElementEnumerator( myString )

      ' Displays the values returned by ElementIndex, Current and GetTextElement.
      ' Current and GetTextElement return a string containing the entire text element.
      Console.WriteLine("Index" + ControlChars.Tab + "Current" + ControlChars.Tab + "GetTextElement")
      myTEE.Reset()
      While myTEE.MoveNext()
         Console.WriteLine("[{0}]:" + ControlChars.Tab + "{1}" + ControlChars.Tab + "{2}", myTEE.ElementIndex, myTEE.Current, myTEE.GetTextElement())
      End While

   End Sub

End Class

'This code produces the following output.  The question marks take the place of high and low surrogates.
'
'Index   Current GetTextElement
'[0]:    𐀀       𐀀
'[2]:    à       à
'[4]:    Æ       Æ

Remarques

Le .NET Framework 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 graphique. Un élément de texte peut être l’un des éléments suivants :

• Caractère de base, qui est représenté sous la forme d’une valeur unique Char . Par exemple, LETTRE MAJUSCULE LATINE A (U+0041) et LETTRE MINUSCULE LATINE AE (U+00E6) sont des caractères de base.

• Séquence de caractères combinant, qui se compose d’un caractère de base et d’un ou plusieurs caractères combinés. Par exemple, la LETTRE MAJUSCULE LATINE A (U+0041) suivie de COMBINING MACRON (U+0304) est une séquence de caractères combinant.

• Paires de substitution, que la norme Unicode définit 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 : un substitut élevé et un substitut faible. Les paires de substitution sont utilisées pour représenter des caractères en dehors du plan multilingue de base Unicode sous forme de caractères encodés en UTF-16. Par exemple, LA LETTRE GOTHIQUE SAUIL (U+10343) est représentée dans l’encodage UTF-16 comme un substitut élevé dont la valeur est 0xD800 et un substitut faible dont la valeur est 0xDF43. Une paire de substitution peut représenter un caractère de base ou un caractère de combinaison.

La TextElementEnumerator classe vous permet d’utiliser les éléments de texte dans une chaîne plutôt qu’avec des objets uniques Char .

Vous instanciez un TextElementEnumerator objet qui représente une chaîne particulière en passant la chaîne à la StringInfo.GetTextElementEnumerator méthode . Cette opération retourne un énumérateur positionné avant le premier élément de texte de la chaîne. L’appel de la Reset méthode ramène également l’énumérateur à cette position. Étant donné que cela représente un état non valide, vous devez appeler MoveNext pour faire avancer l’énumérateur vers le premier élément de texte de la chaîne avant de lire la valeur de la Current propriété pour renvoyer l’élément de texte actuel.

Lorsque vous travaillez avec un TextElementEnumerator objet, vous êtes responsable du positionnement de l’énumérateur. La Current propriété retourne le même élément de texte jusqu’à ce que vous appeliez MoveNext ou Reset. L’énumérateur n’est pas valide s’il est positionné avant le premier élément de texte ou après le dernier élément de texte de la chaîne. Lorsque l’énumérateur est dans un état non valide, la tentative de récupération de la valeur de la Current propriété lève une exception. Vous pouvez déterminer si l’énumérateur est dans un état non valide en testant si la valeur de retour de la MoveNext propriété est false.

L’objet TextElementEnumerator représente une instantané de l’état actuel d’une variable de chaîne ou d’un littéral de chaîne au moment où l’objet TextElementEnumerator est instancié. Notez les points suivants :

• Les énumérateurs d’éléments de texte ne peuvent être utilisés que pour lire des données dans une chaîne. Ils ne peuvent pas modifier la chaîne sous-jacente.

• Un énumérateur n’a pas un accès exclusif à la chaîne qu’il représente. Une variable de chaîne peut être modifiée après la création de l’énumérateur.

• Un TextElementEnumerator objet énumère les éléments de texte présents dans la chaîne au moment où l’objet TextElementEnumerator a été instancié. Il ne reflète pas les modifications ultérieures apportées à la variable de chaîne si cette variable est modifiée par la suite.

• Étant donné que la TextElementEnumerator classe ne remplace Object.Equalspas , deux TextElementEnumerator objets qui représentent la même chaîne seront considérés comme inégaux.

Propriétés

Méthodes

S’applique à

Voir aussi

• StringInfo