TextElementEnumerator Class

Definition

Énumère les éléments de texte d'une chaîne.Enumerates the text elements of a string.

public ref class TextElementEnumerator : System::Collections::IEnumerator
public class TextElementEnumerator : System.Collections.IEnumerator
[System.Serializable]
public class TextElementEnumerator : System.Collections.IEnumerator
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class TextElementEnumerator : System.Collections.IEnumerator
type TextElementEnumerator = class
    interface IEnumerator
Public Class TextElementEnumerator
Implements IEnumerator
Inheritance
TextElementEnumerator
Attributes
Implements

Examples

L’exemple suivant utilise la classe TextElementEnumerator pour énumérer les éléments de texte d’une chaîne.The following example uses the TextElementEnumerator class to enumerate the text elements of a string.

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]:    a`      a`
[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]:    a`      a`
[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]:    a`      a`
'[4]:    Æ       Æ

Remarks

L' .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, autrement dit un graphèmes.The .NET Framework defines a text element as a unit of text that is displayed as a single character, that is, a grapheme. Un élément de texte peut être l’un des éléments suivants :A text element can be any of the following:

  • Caractère de base, représenté sous la forme d’une valeur de Char unique.A base character, which is represented as a single Char value. Par exemple, la lettre majuscule latine A (U + 0041) et la lettre minuscule latine AE (U + 00E6) sont des caractères de base.For example, LATIN CAPITAL LETTER A (U+0041) and LATIN SMALL LETTER AE (U+00E6) are base characters.

  • Séquence de caractères d’association, qui se compose d’un caractère de base et d’un ou de plusieurs caractères d’association.A combining character sequence, which consists of a base character and one or more combining characters. Par exemple, la lettre majuscule latine A (U + 0041) suivie d’une combinaison de MACROn (U + 0304) est une séquence de caractères d’association.For example, example, LATIN CAPITAL LETTER A (U+0041) followed by COMBINING MACRON (U+0304) is a combining character sequence.

  • Les paires de substitution, que la norme Unicode définit comme une représentation de caractère codé pour un caractère abstrait unique qui se compose d’une séquence de deux unités de code : un substitut étendu et un substitut faible.Surrogate pairs, which the Unicode Standard defines as a coded character representation for a single abstract character that consists of a sequence of two code units: a high surrogate, and a low surrogate. Les paires de substitution sont utilisées pour représenter des caractères en dehors du plan multilingue de base Unicode en tant que caractères encodés en UTF-16.Surrogate pairs are used to represent characters outside of the Unicode Basic Multilingual Plane as UTF-16 encoded characters. Par exemple, la lettre GOTHIC SAUIL (U + 10343) est représentée dans l’encodage UTF-16 comme un substitut étendu dont la valeur est 0xD800 et un substitut faible dont la valeur est 0xDF43.For example, GOTHIC LETTER SAUIL (U+10343) is represented in UTF-16 encoding as a high surrogate whose value is 0xD800 and a low surrogate whose value is 0xDF43. Une paire de substitution peut représenter un caractère de base ou un caractère d’association.A surrogate pair can represent a base character or a combining character.

La classe TextElementEnumerator vous permet d’utiliser les éléments de texte d’une chaîne plutôt qu’avec des objets Char uniques.The TextElementEnumerator class allows you to work with the text elements in a string rather than with single Char objects.

Vous instanciez un objet TextElementEnumerator qui représente une chaîne particulière en passant la chaîne à la méthode StringInfo.GetTextElementEnumerator.You instantiate a TextElementEnumerator object that represents a particular string by passing the string to the StringInfo.GetTextElementEnumerator method. Cela retourne un énumérateur positionné avant le premier élément de texte de la chaîne.This returns an enumerator that is positioned before the first text element in the string. L’appel de la méthode Reset ramène également l’énumérateur à cette position.Calling the Reset method also brings the enumerator back to this position. Étant donné qu’il s’agit d’un État non valide, vous devez appeler MoveNext pour avancer l’énumérateur jusqu’au premier élément de texte de la chaîne avant de lire la valeur de la propriété Current pour retourner l’élément de texte actuel.Because this represents an invalid state, you must call MoveNext to advance the enumerator to the first text element of the string before reading the value of the Current property to return the current text element.

Lorsque vous utilisez un objet TextElementEnumerator, vous êtes chargé de positionner l’énumérateur.When working with a TextElementEnumerator object, you are responsible for positioning the enumerator. La propriété Current retourne le même élément de texte jusqu’à ce que vous appeliez MoveNext ou Reset.The Current property returns the same text element until you call either MoveNext or Reset. L’énumérateur est dans un État non 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.The enumerator is in an invalid state if it is positioned before the first text element or after the last text element in the string. Lorsque l’énumérateur est dans un État non valide, toute tentative de récupération de la valeur de la propriété Current lève une exception.When the enumerator is in an invalid state, attempting to retrieve the value of the Current property throws an exception. Vous pouvez déterminer si l’énumérateur est dans un État non valide en vérifiant si la valeur de retour de la propriété MoveNext est false.You can determine whether the enumerator is in an invalid state by testing whether the return value of the MoveNext property is false.

L’objet TextElementEnumerator représente un 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é.The TextElementEnumerator object represents a snapshot of the current state of a string variable or string literal at the moment that the TextElementEnumerator object is instantiated. Notez les points suivants :Note that:

  • Les énumérateurs d’éléments de texte ne peuvent être utilisés que pour lire des données dans une chaîne.Text element enumerators can only be used to read data in a string. Ils ne peuvent pas modifier la chaîne sous-jacente.They cannot modify the underlying string.

  • Un énumérateur ne dispose pas d’un accès exclusif à la chaîne qu’il représente.An enumerator does not have exclusive access to the string that it represents. Une variable de chaîne peut être modifiée après la création de l’énumérateur.A string variable can be modified after the enumerator is created.

  • Un objet TextElementEnumerator énumère les éléments de texte présents dans la chaîne au moment de l’instanciation de l’objet TextElementEnumerator.A TextElementEnumerator object enumerates the text elements present in the string at the time that the TextElementEnumerator object was instantiated. Elle ne reflète pas les modifications ultérieures apportées à la variable de chaîne si cette variable est modifiée par la suite.It does not reflect any subsequent changes to the string variable if that variable is modified afterward.

  • Étant donné que la classe TextElementEnumerator ne remplace pas Object.Equals, deux objets TextElementEnumerator qui représentent la même chaîne seront considérés comme inégaux.Because the TextElementEnumerator class does not override Object.Equals, two TextElementEnumerator objects that represent the same string will be considered unequal.

Properties

Current

Obtient l'élément de texte actuel dans la chaîne.Gets the current text element in the string.

ElementIndex

Obtient l'index de l'élément de texte sur lequel l'énumérateur est actuellement positionné.Gets the index of the text element that the enumerator is currently positioned over.

Methods

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetTextElement()

Obtient l'élément de texte actuel dans la chaîne.Gets the current text element in the string.

GetType()

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

(Inherited from Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
MoveNext()

Fait avancer l'énumérateur à l'élément de texte suivant de la chaîne.Advances the enumerator to the next text element of the string.

Reset()

Affecte à l'énumérateur sa position initiale, qui précède le premier élément de texte de la chaîne.Sets the enumerator to its initial position, which is before the first text element in the string.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Applies to

See also