Compartir vía

StringInfo.GetTextElementEnumerator Método

  • Referencia

Definición

Espacio de nombres:
System.Globalization
Ensamblado:
System.Globalization.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Devuelve un enumerador que recorre en iteración los elementos de texto de una cadena.

Sobrecargas

GetTextElementEnumerator(String)

Devuelve un enumerador que recorre en iteración los elementos de toda la cadena.
GetTextElementEnumerator(String, Int32)

Devuelve un enumerador que recorre en iteración los elementos de texto de la cadena, empezando en el índice especificado.

GetTextElementEnumerator(String)

Source:
StringInfo.cs
Source:
StringInfo.cs
Source:
StringInfo.cs

Devuelve un enumerador que recorre en iteración los elementos de toda la cadena.

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.

Devoluciones

TextElementEnumerator

TextElementEnumerator para toda la cadena.

Excepciones

ArgumentNullException

str es null.

Ejemplos

En el ejemplo siguiente se muestra la forma de llamar al método GetTextElementEnumerator. Este ejemplo forma parte de un ejemplo más grande proporcionado para la StringInfo clase .

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 'ā̈'
// Character at index 3 is 'b'
// Character at index 4 is 'ç'
//
// 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 'ā̈'
'       Character at index 3 is 'b'
'       Character at index 4 is 'ç'
'       
'       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 solo carácter, es decir, un grafo. Un elemento de texto puede ser un carácter base, un par suplente o una secuencia de caracteres combinada. El estándar Unicode define un par suplente como una representación de caracteres codificada 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. El estándar Unicode define una secuencia de caracteres combinada como una combinación de un carácter base y uno o varios caracteres combinados. Un par suplente puede representar un carácter base o un carácter combinado.

El enumerador de elementos de texto solo se usa para leer datos en la cadena; no puede modificar la cadena subyacente. El enumerador no tiene acceso exclusivo a la cadena.

El enumerador está en un estado no válido si se coloca antes del primer elemento de texto de la cadena o después del último elemento de texto de la cadena. Cuando el enumerador está en un estado no válido, la llamada Current produce una excepción.

Inicialmente, el enumerador se coloca antes del primer elemento de texto de la cadena. Reset también devuelve el enumerador a esta posición. Por lo tanto, después de crear un enumerador o después Reset de llamar a , MoveNext debe llamarse para avanzar el enumerador al primer elemento de texto de la cadena antes de leer el valor de Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext o a Reset.

Después de pasar el final de la cadena, el enumerador vuelve a estar en un estado no válido y al llamar a MoveNext devuelve false. La llamada Current produce una excepción si la última llamada a MoveNext devolvió false.

Consulte también

Se aplica a

GetTextElementEnumerator(String, Int32)

Source:
StringInfo.cs
Source:
StringInfo.cs
Source:
StringInfo.cs

Devuelve un enumerador que recorre en iteración los elementos de texto de la cadena, empezando en el índice especificado.

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.

index
Int32

Índice de base cero donde comienza la iteración.

Devoluciones

TextElementEnumerator

TextElementEnumerator para la cadena empezando en index.

Excepciones

ArgumentNullException

str es null.

ArgumentOutOfRangeException

index está fuera del intervalo de índices válidos para la str.

Comentarios

.NET define un elemento de texto como una unidad de texto que se muestra como un solo carácter, es decir, un grafo. Un elemento de texto puede ser un carácter base, un par suplente o una secuencia de caracteres combinada. El estándar Unicode define un par suplente como una representación de caracteres codificada 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. El estándar Unicode define una secuencia de caracteres combinada como una combinación de un carácter base y uno o varios caracteres combinados. Un par suplente puede representar un carácter base o un carácter combinado.

El enumerador de elementos de texto solo se usa para leer datos en la cadena; no puede modificar la cadena subyacente. El enumerador no tiene acceso exclusivo a la cadena.

El enumerador está en un estado no válido si se coloca antes del primer elemento de texto de la cadena o después del último elemento de texto de la cadena. Cuando el enumerador está en un estado no válido, la llamada Current produce una excepción.

Inicialmente, el enumerador se coloca antes del primer elemento de texto de la cadena. Reset también devuelve el enumerador a esta posición. Por lo tanto, después de crear un enumerador o después Reset de llamar a , MoveNext debe llamarse para avanzar el enumerador al primer elemento de texto de la cadena antes de leer el valor de Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext o a Reset.

Después de pasar el final de la cadena, el enumerador vuelve a estar en un estado no válido y al llamar a MoveNext devuelve false. La llamada Current produce una excepción si la última llamada a MoveNext devolvió false.

Consulte también

Se aplica a