TextElementEnumerator Classe

Définition

É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
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class TextElementEnumerator : System.Collections.IEnumerator
type TextElementEnumerator = class
    interface IEnumerator
Public Class TextElementEnumerator
Implements IEnumerator
Héritage
TextElementEnumerator
Attributs
Implémente

Exemples

L’exemple suivant utilise la TextElementEnumerator classe 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]:    Æ       Æ

Remarques

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

Vous instanciez TextElementEnumerator un objet qui représente une chaîne particulière en passant la chaîne à StringInfo.GetTextElementEnumerator la méthode.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 Reset de la méthode 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 MoveNext valide, vous devez appeler pour avancer l’énumérateur jusqu’au premier élément de texte de la chaîne Current avant de lire la valeur de la propriété 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 travaillez avec TextElementEnumerator un objet, vous êtes chargé de positionner l’énumérateur.When working with a TextElementEnumerator object, you are responsible for positioning the enumerator. La Current propriété retourne le même élément de texte jusqu’à ce MoveNext que Resetvous appeliez ou.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 Current valeur de la propriété 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 MoveNext retour de falsela propriété est.You can determine whether the enumerator is in an invalid state by testing whether the return value of the MoveNext property is false.

L' TextElementEnumerator objet représente un instantané de l’état actuel d’une variable de chaîne ou d’un littéral de chaîne au TextElementEnumerator moment où l’objet 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. Prenez note de ce qui suit :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 TextElementEnumerator objet énumère les éléments de texte présents dans la chaîne au moment où l' TextElementEnumerator objet a été instancié.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é TextElementEnumerator que la classe ne se Object.Equalssubstitue TextElementEnumerator pas, deux objets 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.

Propriétés

Current

Obtient l'élément de texte en cours 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.

Méthodes

Equals(Object)

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

(Hérité de Object)
GetHashCode()

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

(Hérité de Object)
GetTextElement()

Obtient l'élément de texte en cours 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.

(Hérité de Object)
MemberwiseClone()

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

(Hérité de 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 en cours.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Voir aussi