TextElementEnumerator Classe

Definizione

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

Ereditarietà

Object

TextElementEnumerator

Attributi

SerializableAttribute ComVisibleAttribute

Implementazioni

IEnumerator

Esempio

Nell'esempio seguente viene usata la TextElementEnumerator classe per enumerare gli elementi di testo di una stringa.

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]:    à       à
[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]:    à       à
[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]:    à       à
'[4]:    Æ       Æ

Commenti

.NET Framework definisce un elemento di testo come unità di testo visualizzato come singolo carattere, ovvero un grafo. Un elemento di testo può essere uno dei seguenti:

• Carattere di base, rappresentato come singolo Char valore. Ad esempio, LA LETTERA MAIUSCOLA LATINA A (U+0041) e L'AE (U+00E6) sono caratteri di base.

• Una sequenza di caratteri combinata, costituita da un carattere di base e uno o più caratteri combinati. Ad esempio, la LETTERA MAIUSCOLA LATINA A (U+0041) seguita da MIX MACRON (U+0304) è una sequenza di caratteri combinata.

• Coppie surrogate, che lo Standard Unicode definisce come rappresentazione di caratteri codificati per un singolo carattere astratto costituito da una sequenza di due unità di codice: un surrogato elevato e un surrogato basso. Le coppie surrogate vengono usate per rappresentare i caratteri esterni al piano multilingue Unicode Basic come caratteri codificati UTF-16. Ad esempio, LA LETTERA GOTICA SAUIL (U+10343) è rappresentata nella codifica UTF-16 come surrogato elevato il cui valore è 0xD800 e un surrogato basso il cui valore è 0xDF43. Una coppia surrogata può rappresentare un carattere di base o un carattere di combinazione.

La TextElementEnumerator classe consente di usare gli elementi di testo in una stringa anziché con singoli Char oggetti.

Si crea un'istanza di un TextElementEnumerator oggetto che rappresenta una determinata stringa passando la stringa al StringInfo.GetTextElementEnumerator metodo. Restituisce un enumeratore posizionato prima del primo elemento di testo nella stringa. La chiamata al metodo restituisce anche l'enumeratore Reset in questa posizione. Poiché questo rappresenta uno stato non valido, è necessario chiamare MoveNext per avanzare l'enumeratore al primo elemento di testo della stringa prima di leggere il valore della Current proprietà per restituire l'elemento di testo corrente.

Quando si usa un TextElementEnumerator oggetto, si è responsabili della posizione dell'enumeratore. La Current proprietà restituisce lo stesso elemento di testo finché non si chiama MoveNext o Reset. L'enumeratore si trova in uno stato non valido se viene posizionato prima del primo elemento di testo o dopo l'ultimo elemento di testo nella stringa. Quando l'enumeratore si trova in uno stato non valido, il tentativo di recuperare il valore della Current proprietà genera un'eccezione. È possibile determinare se l'enumeratore è in uno stato non valido verificando se il valore restituito della MoveNext proprietà è false.

L'oggetto TextElementEnumerator rappresenta uno snapshot dello stato corrente di una variabile stringa o di un valore letterale stringa al momento in cui l'oggetto viene creata un'istanza TextElementEnumerator . Tenere presente quanto segue:

• Gli enumeratori degli elementi di testo possono essere usati solo per leggere i dati in una stringa. Non possono modificare la stringa sottostante.

• Un enumeratore non ha accesso esclusivo alla stringa che rappresenta. Una variabile stringa può essere modificata dopo la creazione dell'enumeratore.

• Un TextElementEnumerator oggetto enumera gli elementi di testo presenti nella stringa al momento della creazione di un'istanza dell'oggetto TextElementEnumerator . Non riflette le modifiche successive apportate alla variabile stringa se tale variabile viene modificata successivamente.

• Poiché la classe non esegue l'override TextElementEnumeratorObject.Equalsdi , due TextElementEnumerator oggetti che rappresentano la stessa stringa verranno considerati non uguali.

Proprietà

Metodi

Si applica a

Vedi anche

• StringInfo