StringInfo.GetTextElementEnumerator Método

Definición

Devuelve un enumerador que recorre en iteración los elementos de texto de una cadena.Returns an enumerator that iterates through the text elements of a string.

Sobrecargas

GetTextElementEnumerator(String)

Devuelve un enumerador que recorre en iteración los elementos de toda la cadena.Returns an enumerator that iterates through the text elements of the entire string.

GetTextElementEnumerator(String, Int32)

Devuelve un enumerador que recorre en iteración los elementos de texto de la cadena, empezando en el índice especificado.Returns an enumerator that iterates through the text elements of the string, starting at the specified index.

GetTextElementEnumerator(String)

Devuelve un enumerador que recorre en iteración los elementos de toda la cadena.Returns an enumerator that iterates through the text elements of the entire string.

public:
 static System::Globalization::TextElementEnumerator ^ GetTextElementEnumerator(System::String ^ str);
public static System.Globalization.TextElementEnumerator GetTextElementEnumerator (string str);
static member GetTextElementEnumerator : string -> System.Globalization.TextElementEnumerator
Public Shared Function GetTextElementEnumerator (str As String) As TextElementEnumerator

Parámetros

str
String

La cadena que se va a recorrer en iteración.The string to iterate through.

Devoluciones

TextElementEnumerator para toda la cadena.A TextElementEnumerator for the entire string.

Excepciones

str es null.str is null.

Ejemplos

En el ejemplo siguiente se muestra la forma de llamar al método GetTextElementEnumerator.The following example demonstrates calling the GetTextElementEnumerator method. Este ejemplo forma parte de un ejemplo más extenso proporcionado para la clase StringInfo.This example is part of a larger example provided for the StringInfo class.

using namespace System;
using namespace System::Text;
using namespace System::Globalization;


// Show how to enumerate each real character (honoring surrogates)
// in a string.

void EnumTextElements(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the enumerator returned from GetTextElementEnumerator
    // method to examine each real character.
    TextElementEnumerator^ charEnum =
        StringInfo::GetTextElementEnumerator(combiningChars);
    while (charEnum->MoveNext())
    {
        sb->AppendFormat("Character at index {0} is '{1}'{2}", 
            charEnum->ElementIndex, charEnum->GetTextElement(), 
            Environment::NewLine);
    }

    // Show the results.
    Console::WriteLine("Result of GetTextElementEnumerator:");
    Console::WriteLine(sb);
}


// Show how to discover the index of each real character
// (honoring surrogates) in a string.

void EnumTextElementIndexes(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the ParseCombiningCharacters method to
    // get the index of each real character in the string.
    array <int>^ textElemIndex =
        StringInfo::ParseCombiningCharacters(combiningChars);

    // Iterate through each real character showing the character
    // and the index where it was found.
    for (int i = 0; i < textElemIndex->Length; i++)
    {
        sb->AppendFormat("Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment::NewLine);
    }

    // Show the results.
    Console::WriteLine("Result of ParseCombiningCharacters:");
    Console::WriteLine(sb);
}

int main()
{

    // The string below contains combining characters.
    String^ combiningChars = L"a\u0304\u0308bc\u0327";

    // Show each 'character' in the string.
    EnumTextElements(combiningChars);

    // Show the index in the string where each 'character' starts.
    EnumTextElementIndexes(combiningChars);

};

// This code produces the following output.
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'a-"'
// Character at index 3 is 'b'
// Character at index 4 is 'c,'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4
using System;
using System.Text;
using System.Globalization;

public sealed class App {
   static void Main() {
      // The string below contains combining characters.
      String s = "a\u0304\u0308bc\u0327";

      // Show each 'character' in the string.
      EnumTextElements(s);

      // Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s);
   }

   // Show how to enumerate each real character (honoring surrogates) in a string.
   static void EnumTextElements(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the enumerator returned from GetTextElementEnumerator 
      // method to examine each real character.
      TextElementEnumerator charEnum = StringInfo.GetTextElementEnumerator(s);
      while (charEnum.MoveNext()) {
         sb.AppendFormat(
           "Character at index {0} is '{1}'{2}",
           charEnum.ElementIndex, charEnum.GetTextElement(),
           Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:");
      Console.WriteLine(sb);
   }

   // Show how to discover the index of each real character (honoring surrogates) in a string.
   static void EnumTextElementIndexes(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the ParseCombiningCharacters method to 
      // get the index of each real character in the string.
      Int32[] textElemIndex = StringInfo.ParseCombiningCharacters(s);

      // Iterate through each real character showing the character and the index where it was found.
      for (Int32 i = 0; i < textElemIndex.Length; i++) {
         sb.AppendFormat(
            "Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:");
      Console.WriteLine(sb);
   }
}

// This code produces the following output.
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'a-"'
// Character at index 3 is 'b'
// Character at index 4 is 'c,'
// 
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4
Imports System.Text
Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' The string below contains combining characters.
      Dim s As String = "a" + ChrW(&h0304) + ChrW(&h0308) + "bc" + ChrW(&h0327)

      ' Show each 'character' in the string.
      EnumTextElements(s)

      ' Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s)
   End Sub

   ' Show how to enumerate each real character (honoring surrogates) in a string.
   Sub EnumTextElements(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

      ' Use the enumerator returned from GetTextElementEnumerator 
      ' method to examine each real character.
      Dim charEnum As TextElementEnumerator = StringInfo.GetTextElementEnumerator(s)
      Do While charEnum.MoveNext()
         sb.AppendFormat("Character at index {0} is '{1}'{2}",
                         charEnum.ElementIndex, 
                         charEnum.GetTextElement(),
                         Environment.NewLine)
      Loop

      ' Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:")
      Console.WriteLine(sb)
   End Sub

   ' Show how to discover the index of each real character (honoring surrogates) in a string.
   Sub EnumTextElementIndexes(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

      ' Use the ParseCombiningCharacters method to 
      ' get the index of each real character in the string.
      Dim textElemIndex() As Integer = StringInfo.ParseCombiningCharacters(s)

      ' Iterate through each real character showing the character and the index where it was found.
      For i As Int32 = 0 To textElemIndex.Length - 1
         sb.AppendFormat("Character {0} starts at index {1}{2}",
                         i, textElemIndex(i), Environment.NewLine)
      Next

      ' Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:")
      Console.WriteLine(sb)
   End Sub
End Module
' The example displays the following output:
'       Result of GetTextElementEnumerator:
'       Character at index 0 is 'a-"'
'       Character at index 3 is 'b'
'       Character at index 4 is 'c,'
'       
'       Result of ParseCombiningCharacters:
'       Character 0 starts at index 0
'       Character 1 starts at index 3
'       Character 2 starts at index 4

Comentarios

.NET define un elemento de texto como una unidad de texto que se muestra como un único carácter, es decir, un grapheme..NET 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 un carácter base, un par suplente o una secuencia de caracteres combinable.A text element can be a base character, a surrogate pair, or a combining character sequence. El estándar Unicode define un par suplente como una representación de caracteres codificados para un único carácter abstracto que consta de una secuencia de dos unidades de código, donde la primera unidad del par es un suplente alto y la segunda es un suplente bajo.The Unicode Standard defines a surrogate pair as a coded character representation for a single abstract character that consists of a sequence of two code units, where the first unit of the pair is a high surrogate and the second is a low surrogate. El estándar Unicode define una secuencia de caracteres de combinación como una combinación de un carácter base y uno o más caracteres combinados.The Unicode Standard defines a combining character sequence as a combination of a base character and one or more combining characters. 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.

El enumerador de elementos de texto solo se usa para leer los datos de la cadena; no puede modificar la cadena subyacente.The text element enumerator is used only to read data in the string; it cannot modify the underlying string. El enumerador no tiene acceso exclusivo a la cadena.The enumerator does not have exclusive access to the string.

El enumerador se encuentra en un estado no válido si se coloca delante del primer elemento de texto de la cadena 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 in the string or after the last text element in the string. Cuando el enumerador se encuentra en un estado no válido, al llamar a Current se produce una excepción.When the enumerator is in an invalid state, calling Current throws an exception.

Inicialmente, el enumerador se coloca delante del primer elemento de texto de la cadena.Initially, the enumerator is positioned before the first text element in the string. Reset también devuelve el enumerador a esta posición.Reset also brings the enumerator back to this position. Por lo tanto, después de crear un enumerador o después de llamar a Reset, se debe llamar a MoveNext para avanzar el enumerador hasta el primer elemento de texto de la cadena antes de leer el valor de Current.Therefore, after an enumerator is created or after Reset is called, MoveNext must be called to advance the enumerator to the first text element of the string before reading the value of Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext o a Reset.Current returns the same object until either MoveNext or Reset is called.

Una vez pasado el final de la cadena, el enumerador vuelve a estar en un estado no válido y, al llamar a MoveNext, se devuelve false.After the end of the string is passed, the enumerator is again in an invalid state and calling MoveNext returns false. La llamada a Current produce una excepción si la última llamada a MoveNext devolvió false.Calling Current throws an exception if the last call to MoveNext returned false.

Consulte también:

GetTextElementEnumerator(String, Int32)

Devuelve un enumerador que recorre en iteración los elementos de texto de la cadena, empezando en el índice especificado.Returns an enumerator that iterates through the text elements of the string, starting at the specified index.

public:
 static System::Globalization::TextElementEnumerator ^ GetTextElementEnumerator(System::String ^ str, int index);
public static System.Globalization.TextElementEnumerator GetTextElementEnumerator (string str, int index);
static member GetTextElementEnumerator : string * int -> System.Globalization.TextElementEnumerator
Public Shared Function GetTextElementEnumerator (str As String, index As Integer) As TextElementEnumerator

Parámetros

str
String

La cadena que se va a recorrer en iteración.The string to iterate through.

index
Int32

Índice de base cero donde comienza la iteración.The zero-based index at which to start iterating.

Devoluciones

TextElementEnumerator para la cadena empezando en index.A TextElementEnumerator for the string starting at index.

Excepciones

str es null.str is null.

index está fuera del intervalo de índices válidos para la str.index is outside the range of valid indexes for str.

Comentarios

.NET define un elemento de texto como una unidad de texto que se muestra como un único carácter, es decir, un grapheme..NET 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 un carácter base, un par suplente o una secuencia de caracteres combinable.A text element can be a base character, a surrogate pair, or a combining character sequence. El estándar Unicode define un par suplente como una representación de caracteres codificados para un único carácter abstracto que consta de una secuencia de dos unidades de código, donde la primera unidad del par es un suplente alto y la segunda es un suplente bajo.The Unicode Standard defines a surrogate pair as a coded character representation for a single abstract character that consists of a sequence of two code units, where the first unit of the pair is a high surrogate and the second is a low surrogate. El estándar Unicode define una secuencia de caracteres de combinación como una combinación de un carácter base y uno o más caracteres combinados.The Unicode Standard defines a combining character sequence as a combination of a base character and one or more combining characters. 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.

El enumerador de elementos de texto solo se usa para leer los datos de la cadena; no puede modificar la cadena subyacente.The text element enumerator is used only to read data in the string; it cannot modify the underlying string. El enumerador no tiene acceso exclusivo a la cadena.The enumerator does not have exclusive access to the string.

El enumerador se encuentra en un estado no válido si se coloca delante del primer elemento de texto de la cadena 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 in the string or after the last text element in the string. Cuando el enumerador se encuentra en un estado no válido, al llamar a Current se produce una excepción.When the enumerator is in an invalid state, calling Current throws an exception.

Inicialmente, el enumerador se coloca delante del primer elemento de texto de la cadena.Initially, the enumerator is positioned before the first text element in the string. Reset también devuelve el enumerador a esta posición.Reset also brings the enumerator back to this position. Por lo tanto, después de crear un enumerador o después de llamar a Reset, se debe llamar a MoveNext para avanzar el enumerador hasta el primer elemento de texto de la cadena antes de leer el valor de Current.Therefore, after an enumerator is created or after Reset is called, MoveNext must be called to advance the enumerator to the first text element of the string before reading the value of Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext o a Reset.Current returns the same object until either MoveNext or Reset is called.

Una vez pasado el final de la cadena, el enumerador vuelve a estar en un estado no válido y, al llamar a MoveNext, se devuelve false.After the end of the string is passed, the enumerator is again in an invalid state and calling MoveNext returns false. La llamada a Current produce una excepción si la última llamada a MoveNext devolvió false.Calling Current throws an exception if the last call to MoveNext returned false.

Consulte también:

Se aplica a