CharEnumerator CharEnumerator CharEnumerator CharEnumerator Class

Definizione

Supporta lo scorrimento su un oggetto String e la lettura dei singoli caratteri.Supports iterating over a String object and reading its individual characters. Questa classe non può essere ereditata.This class cannot be inherited.

public ref class CharEnumerator sealed : ICloneable, System::Collections::Generic::IEnumerator<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class CharEnumerator : ICloneable, System.Collections.Generic.IEnumerator<char>
type CharEnumerator = class
    interface IEnumerator
    interface ICloneable
    interface IEnumerator<char>
    interface IDisposable
Public NotInheritable Class CharEnumerator
Implements ICloneable, IEnumerator(Of Char)
Ereditarietà
CharEnumeratorCharEnumeratorCharEnumeratorCharEnumerator
Attributi
Implementazioni

Esempi

L'esempio seguente usa il CharEnumerator classe per enumerare i singoli caratteri in una stringa.The following example uses the CharEnumerator class to enumerate the individual characters in a string. Crea un'istanza di un CharEnumerator oggetto chiamando il String.GetEnumerator passa da un carattere (metodo), al successivo chiamando il MoveNext metodo e visualizza il carattere corrente recuperando il valore del Current proprietà.It instantiates a CharEnumerator object by calling the String.GetEnumerator method, moves from one character to the next by calling the MoveNext method, and displays the current character by retrieving the value of the Current property.

String ^ title = "A Tale of Two Cities";
CharEnumerator ^ chEnum = title->GetEnumerator();
int ctr = 1;
String ^ outputLine1 = nullptr;
String ^ outputLine2 = nullptr;
String ^ outputLine3 = nullptr; 

while (chEnum->MoveNext())
{
   outputLine1 += ctr < 10 || ctr % 10 != 0 ? "  " : (ctr / 10) + " ";
   outputLine2 += (ctr % 10) + " ";
   outputLine3 += chEnum->Current + " ";
   ctr++;
}

Console::WriteLine("The length of the string is {0} characters:", 
                  title->Length);
Console::WriteLine(outputLine1);
Console::WriteLine(outputLine2);    
Console::WriteLine(outputLine3);
// The example displays the following output to the console:      
//       The length of the string is 20 characters:
//                         1                   2
//       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
//       A   T a l e   o f   T w o   C i t i e s
string title = "A Tale of Two Cities";
CharEnumerator chEnum = title.GetEnumerator();
int ctr = 1;
string outputLine1 = null;
string outputLine2 = null;
string outputLine3 = null; 

while (chEnum.MoveNext())
{
   outputLine1 += ctr < 10 || ctr % 10 != 0 ? "  " : (ctr / 10) + " ";
   outputLine2 += (ctr % 10) + " ";
   outputLine3 += chEnum.Current + " ";
   ctr++;
}

Console.WriteLine("The length of the string is {0} characters:", 
                  title.Length);
Console.WriteLine(outputLine1);
Console.WriteLine(outputLine2);    
Console.WriteLine(outputLine3);
// The example displays the following output to the console:      
//       The length of the string is 20 characters:
//                         1                   2
//       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
//       A   T a l e   o f   T w o   C i t i e s
Dim title As String = "A Tale of Two Cities"
Dim chEnum As CharEnumerator = title.GetEnumerator()
Dim ctr As Integer = 1
Dim outputLine1, outputLine2, outputLine3 As String 

Do While chEnum.MoveNext()
   outputLine1 += CStr(iif(ctr < 10 Or ctr Mod 10 <> 0, "  ", CStr(ctr \ 10) + " ")) 
   outputLine2 += (ctr Mod 10)& " "
   outputLine3 += chEnum.Current & " "
   ctr += 1
Loop

Console.WriteLine("The length of the string is {0} characters:", _
                  title.Length)
Console.WriteLine(outputLine1)
Console.WriteLine(outputLine2)    
Console.WriteLine(outputLine3)
' The example displays the following output to the console:      
'       The length of the string is 20 characters:
'                         1                   2
'       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
'       A   T a l e   o f   T w o   C i t i e s

Si noti tuttavia che la stessa operazione può essere eseguita con un po' più intuitivo usando foreach (in C#) o For Each (in Visual Basic), come illustrato nell'esempio seguente viene illustrato.Note, however, that the same operation can be performed somewhat more intuitively by using foreach (in C#) or For Each (in Visual Basic), as the following example shows.

String ^ title = "A Tale of Two Cities";
int ctr = 1;
String ^ outputLine1 = nullptr;
String ^ outputLine2 = nullptr;
String ^ outputLine3 = nullptr; 

for each (wchar_t ch in title)
{
   outputLine1 += ctr < 10 || ctr % 10 != 0 ? "  " : (ctr / 10) + " ";
   outputLine2 += (ctr % 10) + " ";
   outputLine3 += ch + " ";
   ctr++;
}

Console::WriteLine("The length of the string is {0} characters:", 
                  title->Length);
Console::WriteLine(outputLine1);
Console::WriteLine(outputLine2);    
Console::WriteLine(outputLine3);
// The example displays the following output to the console:      
//       The length of the string is 20 characters:
//                         1                   2
//       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
//       A   T a l e   o f   T w o   C i t i e s
string title = "A Tale of Two Cities";
int ctr = 1;
string outputLine1 = null;
string outputLine2 = null;
string outputLine3 = null; 

foreach (char ch in title)
{
   outputLine1 += ctr < 10 || ctr % 10 != 0 ? "  " : (ctr / 10) + " ";
   outputLine2 += (ctr % 10) + " ";
   outputLine3 += ch + " ";
   ctr++;
}

Console.WriteLine("The length of the string is {0} characters:", 
                  title.Length);
Console.WriteLine(outputLine1);
Console.WriteLine(outputLine2);    
Console.WriteLine(outputLine3);
// The example displays the following output to the console:      
//       The length of the string is 20 characters:
//                         1                   2
//       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
//       A   T a l e   o f   T w o   C i t i e s
Dim title As String = "A Tale of Two Cities"
Dim ctr As Integer = 1
Dim outputLine1, outputLine2, outputLine3 As String 

For Each ch As Char In title
   outputLine1 += CStr(iif(ctr < 10 Or ctr Mod 10 <> 0, "  ", CStr(ctr \ 10) + " ")) 
   outputLine2 += (ctr Mod 10)& " "
   outputLine3 += ch & " "
   ctr += 1
Next

Console.WriteLine("The length of the string is {0} characters:", _
                  title.Length)
Console.WriteLine(outputLine1)
Console.WriteLine(outputLine2)    
Console.WriteLine(outputLine3)
' The example displays the following output to the console:      
'       The length of the string is 20 characters:
'                         1                   2
'       1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
'       A   T a l e   o f   T w o   C i t i e s

Commenti

Oggetto CharEnumerator fornisce l'accesso di sola lettura per i caratteri in un riferimento String oggetto.A CharEnumerator provides read-only access to the characters in a referenced String object. Ad esempio, il foreach istruzione dei linguaggi di programmazione Microsoft Visual Basic e C#, che scorre gli elementi di una raccolta, consente di recuperare una CharEnumerator da un String oggetto per scorrere i caratteri in cui oggetto.For example, the foreach statement of the Microsoft Visual Basic and C# programming languages, which iterates through the elements of a collection, retrieves a CharEnumerator from a String object in order to iterate through the characters in that object.

Importante

Il CharEnumerator classe enumera singoli 16 bit Char istanze.The CharEnumerator class enumerates individual 16-bit Char instances. Non considera grafema (vale a dire, un carattere seguito da uno o più caratteri combiding) o (vale a dire, i caratteri di fuori di Unicode Basic Multilingual Plane) di coppie di surrogati come singoli caratteri.It does not consider graphemes (that is, a character followed by one or more combiding characters) or surrogate pairs (that is, characters outside the Unicode Basic Multilingual Plane) as single characters. Per un enumeratore che gestisce questi tipi di caratteri come singola unità, usare il StringInfo classe.For an enumerator that handles these types of characters as a single unit, use the StringInfo class.

Non vi è alcun costruttore pubblico per CharEnumerator.There is no public constructor for CharEnumerator. Viene invece chiamato un String dell'oggetto GetEnumerator metodo per ottenere un CharEnumerator inizializzato per fare riferimento alla stringa.Instead, call a String object's GetEnumerator method to obtain a CharEnumerator that is initialized to reference the string.

Oggetto CharEnumerator gestisce un indice interno per i caratteri nella stringa di CharEnumerator riferimenti.A CharEnumerator maintains an internal index to the characters in the string the CharEnumerator references. Lo stato dell'indice è non valido quando si fa riferimento a una posizione del carattere in modo logico prima del primo carattere o dopo l'ultimo carattere nella stringa e valido quando si fa riferimento a un carattere all'interno della stringa.The state of the index is invalid when it references a character position logically before the first character or after the last character in the string, and valid when it references a character within the string. L'indice viene inizializzato in una posizione logicamente precedente al primo carattere e viene impostato su una posizione dopo l'ultimo carattere, una volta completata l'iterazione.The index is initialized to a position logically before the first character, and is set to a position after the last character when the iteration is complete. Se si tenta di accedere a un carattere mentre l'indice non è valido, viene generata un'eccezione.An exception is thrown if you attempt to access a character while the index is invalid.

Il MoveNext metodo incrementa l'indice di uno, in modo che i caratteri prima e successive sono accessibili a sua volta.The MoveNext method increments the index by one, so the first and subsequent characters are accessed in turn. Il Reset metodo imposta l'indice in una posizione logicamente precedente al primo carattere.The Reset method sets the index to a position logically before the first character. Il Current proprietà recupera il carattere di indice fa attualmente riferimento.The Current property retrieves the character currently referenced by index. Il Clone metodo crea una copia del CharEnumerator.The Clone method creates a copy of the CharEnumerator.

Nota

Diverse istanze indipendenti di CharEnumerator attraverso uno o più thread possono avere accesso a una singola istanza di String.Several independent instances of CharEnumerator across one or more threads can have access to a single instance of String. Questa classe viene implementata per supportare il IEnumerator interfaccia.This class is implemented to support the IEnumerator interface. Per altre informazioni sull'uso di un enumeratore, vedere il IEnumerator argomento.For more information regarding the use of an enumerator, see the IEnumerator topic.

Proprietà

Current Current Current Current

Ottiene il carattere a cui fa attualmente riferimento nella stringa enumerata questo oggetto CharEnumerator.Gets the currently referenced character in the string enumerated by this CharEnumerator object.

Metodi

Clone() Clone() Clone() Clone()

Crea una copia dell'oggetto CharEnumerator corrente.Creates a copy of the current CharEnumerator object.

Dispose() Dispose() Dispose() Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe CharEnumerator.Releases all resources used by the current instance of the CharEnumerator class.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MoveNext() MoveNext() MoveNext() MoveNext()

Incrementa l'indice interno dell'oggetto CharEnumerator corrente sul carattere successivo della stringa enumerata.Increments the internal index of the current CharEnumerator object to the next character of the enumerated string.

Reset() Reset() Reset() Reset()

Inizializza l'indice in una posizione logicamente precedente al primo carattere della stringa enumerata.Initializes the index to a position logically before the first character of the enumerated string.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Rilascia tutte le risorse usate dalla classe CharEnumerator.Releases all resources used by the CharEnumerator class.

IEnumerator.Current IEnumerator.Current IEnumerator.Current IEnumerator.Current

Ottiene il carattere a cui fa attualmente riferimento nella stringa enumerata questo oggetto CharEnumerator.Gets the currently referenced character in the string enumerated by this CharEnumerator object. Per una descrizione di questo membro, vedere Current.For a description of this member, see Current.

Si applica a

Vedi anche