Aplicaciones de Windows
Collapse the table of content
Expand the table of content
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original
Información
El tema que ha solicitado se muestra abajo. Sin embargo, este tema no se encuentra en la biblioteca.

StringInfo (Clase)

 

Proporciona funciones para dividir una cadena en elementos de texto y recorrer en iteración dichos elementos.

Espacio de nombres:   System.Globalization
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.Globalization.StringInfo

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class StringInfo

NombreDescripción
System_CAPS_pubmethodStringInfo()

Inicializa una nueva instancia de la clase StringInfo.

System_CAPS_pubmethodStringInfo(String)

Inicializa una nueva instancia de la clase StringInfo en una cadena especificada.

NombreDescripción
System_CAPS_pubpropertyLengthInTextElements

Obtiene el número de elementos de texto del objeto StringInfo actual.

System_CAPS_pubpropertyString

Obtiene o establece el valor del objeto StringInfo actual.

NombreDescripción
System_CAPS_pubmethodEquals(Object)

Indica si el objeto StringInfo actual es igual a un objeto especificado.(Reemplaza a Object.Equals(Object)).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object.)

System_CAPS_pubmethodGetHashCode()

Calcula un código hash para el valor del objeto StringInfo actual.(Reemplaza a Object.GetHashCode()).

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String)

Obtiene el primer elemento de texto de una cadena especificada.

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String, Int32)

Obtiene el elemento de texto en el índice especificado de la cadena indicada.

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String)

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

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String, Int32)

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

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual. (Heredado de Object.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual. (Heredado de Object.)

System_CAPS_pubmethodSystem_CAPS_staticParseCombiningCharacters(String)

Devuelve los índices de todos los caracteres base, suplentes altos o caracteres de control de la cadena especificada.

System_CAPS_pubmethodSubstringByTextElements(Int32)

Recupera una subcadena de elementos de texto del objeto StringInfo actual empezando en un elemento de texto especificado y continuando hasta el último elemento de texto.

System_CAPS_pubmethodSubstringByTextElements(Int32, Int32)

Recupera una subcadena de elementos de texto del objeto StringInfo actual empezando en un elemento de texto especificado y continuando en el número especificado de elementos de texto.

System_CAPS_pubmethodToString()

Retorna una cadena que representa al objeto actual. (Heredado de Object.)

En .NET Framework se define un elemento de texto como unidad de texto que se muestra como un solo carácter, es decir, un grafema.Un elemento de texto puede ser un carácter base, un par suplente o una secuencia de caracteres de combinación.El estándar Unicodehttp://go.microsoft.com/fwlink/?linkid=37123define un par suplente como representación codificada de caracteres para un único carácter abstracto que consta de una secuencia de dos unidades de código, en el que la primera unidad del par es un suplente alto y la segunda un suplente bajo.El estándar Unicode define una secuencia de caracteres de combinación 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 combinable.

La clase de StringInfo permite ejecutar una cadena como una serie de elementos textuales en lugar de los objetos individuales de Char .Puede ejecutar los elementos individuales de texto en una cadena de dos maneras:

El ejemplo siguiente muestra ambas maneras de trabajar con elementos de texto en una cadena.Crea dos cadenas:

  • strCombining, una cadena de caracteres árabes que incluye tres elementos de texto con varios objetos de Char .El primer elemento de texto es la ALIF ÁRABE de la LATIN de carácter base (U+-627) seguida de HAMZA ÁRABE BELOW (U+-655) y KASRA ÁRABE (U+0650).El segundo elemento de texto es la LATIN ÁRABE HEH (U+0647) seguida de FATHA ÁRABE (U+-64E).El tercer elemento de texto es LETTTER ÁRABE BEH (U+0628) seguido de DAMMATAN ÁRABE (U+064C).

  • strSurrogates, que es una cadena que incluye tres pares suplentes: ACROPHONIC GRIEGO FIVE TALENTS (U+10148) de Supplementary MUI Plane, U+20026 de Supplementary Ideographic Plane, y U+F1001 de usuario privada.La codificación UTF-16 de cada carácter es un par suplente que consta de un suplente alto seguido por un suplente bajo.

Cada cadena se analiza una vez al método de ParseCombiningCharacters y después por el método de GetTextElementEnumerator .Ambos métodos analizan correctamente los elementos de texto en las dos cadenas y muestra los resultados de la operación de análisis.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // The Unicode code points specify Arabic base characters and 
      // combining character sequences.
      string strCombining = "\u0627\u0655\u0650\u064A\u0647\u064E" +
                            "\u0627\u0628\u064C";

      // The Unicode code points specify private surrogate pairs.
      string strSurrogates = Char.ConvertFromUtf32(0x10148) +
                             Char.ConvertFromUtf32(0x20026) + "a" +
                             Char.ConvertFromUtf32(0xF1001);

      EnumerateTextElements(strCombining);
      EnumerateTextElements(strSurrogates);
   }

   public static void EnumerateTextElements(string str)
   {
      // Get the Enumerator.
      TextElementEnumerator teEnum = null;      

      // Parse the string using the ParseCombiningCharacters method.
      Console.WriteLine("\nParsing with ParseCombiningCharacters:");
      int[] teIndices = StringInfo.ParseCombiningCharacters(str);

      for (int i = 0; i < teIndices.Length; i++) {
         if (i < teIndices.Length - 1)
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               teIndices[i], teIndices[i + 1] - 1, 
               ShowHexValues(str.Substring(teIndices[i], teIndices[i + 1] - 
                             teIndices[i])));
         else
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               teIndices[i], str.Length - 1, 
               ShowHexValues(str.Substring(teIndices[i])));
      }
      Console.WriteLine();

      // Parse the string with the GetTextElementEnumerator method.
      Console.WriteLine("Parsing with TextElementEnumerator:");
      teEnum = StringInfo.GetTextElementEnumerator(str);

      int teCount = - 1;

      while (teEnum.MoveNext()) {
         // Displays the current element.
         // Both GetTextElement() and Current retrieve the current
         // text element. The latter returns it as an Object.
         teCount++;
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", teCount, 
            teEnum.ElementIndex, teEnum.ElementIndex + 
            teEnum.GetTextElement().Length - 1, ShowHexValues((string)(teEnum.Current)));
      }
   }

   private static string ShowHexValues(string s)
   {
      string hexString = "";
      foreach (var ch in s)
         hexString += String.Format("{0:X4} ", Convert.ToUInt16(ch));

      return hexString;
   }
}
// The example displays the following output:
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//       
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//       
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01
//       
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01

En este ejemplo se muestra cómo se utilizan los métodos GetTextElementEnumerator y ParseCombiningCharacters de la clase StringInfo para manipular una cadena que contiene caracteres suplentes y combinables.

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

Universal Windows Platform
Disponible desde 4.5
.NET Framework
Disponible desde 1.1
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Volver al principio
Mostrar:
© 2016 Microsoft