TextElementEnumerator Classe

Référence

Définition

Espace de noms:: System.Globalization

Assembly:: System.Globalization.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Énumère les éléments de texte d'une chaîne.

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]:    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

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, autrement dit 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 de combinaison. Par exemple, la LETTRE MAJUSCULE LATINE A (U+0041) suivie de COMBINING ASCII (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 de caractères pour un seul caractère abstrait 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 en tant que caractères encodés UTF-16. Par exemple, LA LETTRE GOTHIQUE SAUIL (U+10343) est représentée en encodage UTF-16 comme 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 renvoie 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. Comme 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 retourner 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 appelons l’un MoveNext ou Resetl’autre . 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. Lorsque l’énumérateur est dans un état non valide, toute 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 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é. Notez les points suivants :

Les énumérateurs d’éléments de texte peuvent uniquement être utilisés 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 d’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é. Elle ne reflète pas les modifications suivantes 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 sont considérés comme inégaux.

Propriétés

Current	Obtient l'élément de texte actuel dans la chaîne.
ElementIndex	Obtient l'index de l'élément de texte sur lequel l'énumérateur est actuellement positionné.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetTextElement()	Obtient l'élément de texte actuel dans la chaîne.
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)
MoveNext()	Fait avancer l'énumérateur à l'élément de texte suivant de la chaîne.
Reset()	Affecte à l'énumérateur sa position initiale, qui précède le premier élément de texte de la chaîne.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à

Voir aussi

StringInfo