TextElementEnumerator Clase

Definición

Enumera los elementos de texto de una cadena.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
Herencia
TextElementEnumerator
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se TextElementEnumerator usa la clase para enumerar los elementos de texto de una cadena.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]:    Æ       Æ

Comentarios

El .NET Framework define un elemento de texto como una unidad de texto que se muestra como un único carácter, es decir, un grapheme.The .NET Framework defines a text element as a unit of text that is displayed as a single character, that is, a grapheme. Un elemento de texto puede ser cualquiera de los siguientes:A text element can be any of the following:

  • Carácter base, que se representa como un valor único Char .A base character, which is represented as a single Char value. Por ejemplo, la letra mayúscula latina A (U + 0041) y letra latina minúscula AE (U + 00E6) son caracteres base.For example, LATIN CAPITAL LETTER A (U+0041) and LATIN SMALL LETTER AE (U+00E6) are base characters.

  • Secuencia de caracteres que se combina, que consta de un carácter base y uno o más caracteres de combinación.A combining character sequence, which consists of a base character and one or more combining characters. Por ejemplo, por ejemplo, la letra mayúscula latina A (U + 0041) seguida de la combinación de MACROs (U + 0304) es una secuencia de caracteres que se combina.For example, example, LATIN CAPITAL LETTER A (U+0041) followed by COMBINING MACRON (U+0304) is a combining character sequence.

  • Pares suplentes, que el estándar Unicode define como una representación de caracteres codificados para un único carácter abstracto que consta de una secuencia de dos unidades de código: un suplente alto y un suplente bajo.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. Los pares suplentes se utilizan para representar caracteres fuera del plano básico multilingüe de Unicode como caracteres codificados en UTF-16.Surrogate pairs are used to represent characters outside of the Unicode Basic Multilingual Plane as UTF-16 encoded characters. Por ejemplo, la letra de GOTHIC SAUIL (U + 10343) se representa en la codificación UTF-16 como un suplente alto cuyo valor es 0xD800 y un suplente bajo cuyo valor es 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. Un par suplente puede representar un carácter base o un carácter de combinación.A surrogate pair can represent a base character or a combining character.

La TextElementEnumerator clase permite trabajar con los elementos de texto en una cadena en lugar de con objetos Char únicos.The TextElementEnumerator class allows you to work with the text elements in a string rather than with single Char objects.

Puede crear una instancia TextElementEnumerator de un objeto que representa una cadena determinada pasando la cadena StringInfo.GetTextElementEnumerator al método.You instantiate a TextElementEnumerator object that represents a particular string by passing the string to the StringInfo.GetTextElementEnumerator method. Esto devuelve un enumerador que se coloca delante del primer elemento de texto de la cadena.This returns an enumerator that is positioned before the first text element in the string. La Reset llamada al método también devuelve el enumerador a esta posición.Calling the Reset method also brings the enumerator back to this position. Como esto representa un estado no válido, debe llamar MoveNext a para avanzar el enumerador hasta el primer elemento de texto de la cadena antes de leer Current el valor de la propiedad para devolver el elemento de texto actual.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.

Al trabajar con un TextElementEnumerator objeto, usted es responsable de colocar el enumerador.When working with a TextElementEnumerator object, you are responsible for positioning the enumerator. La Current propiedad devuelve el mismo elemento de texto hasta que se MoveNext llama Reseta o a.The Current property returns the same text element until you call either MoveNext or Reset. El enumerador se encuentra en un estado no válido si se coloca antes del primer elemento de texto o después del último elemento de texto de la cadena.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. Cuando el enumerador se encuentra en un estado no válido, si se intenta recuperar el Current valor de la propiedad, se produce una excepción.When the enumerator is in an invalid state, attempting to retrieve the value of the Current property throws an exception. Puede determinar si el enumerador se encuentra en un estado no válido comprobando si el valor devuelto de falsela MoveNext propiedad es.You can determine whether the enumerator is in an invalid state by testing whether the return value of the MoveNext property is false.

El TextElementEnumerator objeto representa una instantánea del estado actual de una variable de cadena o un literal de cadena en el momento TextElementEnumerator en que se crea una instancia del objeto.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. Ten en cuenta lo siguiente:Note that:

  • Los enumeradores de elementos de texto solo se pueden usar para leer los datos de una cadena.Text element enumerators can only be used to read data in a string. No pueden modificar la cadena subyacente.They cannot modify the underlying string.

  • Un enumerador no tiene acceso exclusivo a la cadena que representa.An enumerator does not have exclusive access to the string that it represents. Una variable de cadena se puede modificar una vez creado el enumerador.A string variable can be modified after the enumerator is created.

  • Un TextElementEnumerator objeto enumera los elementos de texto presentes en la cadena en el momento en que TextElementEnumerator se creó la instancia del objeto.A TextElementEnumerator object enumerates the text elements present in the string at the time that the TextElementEnumerator object was instantiated. No refleja los cambios posteriores en la variable de cadena si esa variable se modifica después.It does not reflect any subsequent changes to the string variable if that variable is modified afterward.

  • Dado que TextElementEnumerator la clase no invalida Object.Equals, dos TextElementEnumerator objetos que representan la misma cadena se considerarán distintos.Because the TextElementEnumerator class does not override Object.Equals, two TextElementEnumerator objects that represent the same string will be considered unequal.

Propiedades

Current

Obtiene el elemento de texto actual de la cadena.Gets the current text element in the string.

ElementIndex

Obtiene el índice del elemento de texto en el que está situado actualmente el enumerador.Gets the index of the text element that the enumerator is currently positioned over.

Métodos

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetTextElement()

Obtiene el elemento de texto actual de la cadena.Gets the current text element in the string.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
MoveNext()

Desplaza el enumerador al siguiente elemento de texto de la cadena.Advances the enumerator to the next text element of the string.

Reset()

Establece el enumerador en su posición inicial (antes del primer elemento de texto de la cadena).Sets the enumerator to its initial position, which is before the first text element in the string.

ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Se aplica a

Consulte también: