CharEnumerator Classe

Définition

Prend en charge l’itération sur un objet String et la lecture de ses différents caractères.Supports iterating over a String object and reading its individual characters. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class CharEnumerator sealed : ICloneable, System::Collections::Generic::IEnumerator<char>
public ref class CharEnumerator sealed : ICloneable, System::Collections::IEnumerator
public sealed class CharEnumerator : ICloneable, System.Collections.Generic.IEnumerator<char>
[System.Serializable]
public sealed class CharEnumerator : ICloneable, System.Collections.IEnumerator
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class CharEnumerator : ICloneable, System.Collections.Generic.IEnumerator<char>
type CharEnumerator = class
    interface IEnumerator<char>
    interface IEnumerator
    interface IDisposable
    interface ICloneable
type CharEnumerator = class
    interface IEnumerator
    interface ICloneable
type CharEnumerator = class
    interface ICloneable
    interface IEnumerator<char>
    interface IDisposable
    interface IEnumerator
type CharEnumerator = class
    interface ICloneable
    interface IEnumerator<char>
    interface IEnumerator
    interface IDisposable
type CharEnumerator = class
    interface IEnumerator
    interface ICloneable
    interface IEnumerator<char>
    interface IDisposable
Public NotInheritable Class CharEnumerator
Implements ICloneable, IEnumerator(Of Char)
Public NotInheritable Class CharEnumerator
Implements ICloneable, IEnumerator
Héritage
CharEnumerator
Attributs
Implémente

Exemples

L’exemple suivant utilise la classe CharEnumerator pour énumérer les caractères individuels d’une chaîne.The following example uses the CharEnumerator class to enumerate the individual characters in a string. Il instancie un objet CharEnumerator en appelant la méthode String.GetEnumerator, passe d’un caractère à l’autre en appelant la méthode MoveNext et affiche le caractère actuel en extrayant la valeur de la propriété Current.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

Notez, toutefois, que la même opération peut être effectuée un peu plus intuitivement en utilisant foreach ( C#dans) ou For Each (dans Visual Basic), comme le montre l’exemple suivant.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

Remarques

Un CharEnumerator fournit un accès en lecture seule aux caractères d’un objet String référencé.A CharEnumerator provides read-only access to the characters in a referenced String object. Par exemple, l' foreach instruction de l’Visual Basic et C# des langages de programmation Microsoft, qui itère au sein des éléments d’une collection, récupère un CharEnumerator à partir d’un objet String afin d’itérer au sein des caractères de cet objet.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.

Important

La classe CharEnumerator énumère des instances de Char 16 bits individuelles.The CharEnumerator class enumerates individual 16-bit Char instances. Elle ne considère pas graphemes (autrement dit, un caractère suivi d’un ou plusieurs caractères combiding) ou des paires de substitution (autrement dit, les caractères en dehors du plan multilingue de base Unicode) comme des caractères uniques.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. Pour un énumérateur qui gère ces types de caractères en tant qu’unité unique, utilisez la classe StringInfo.For an enumerator that handles these types of characters as a single unit, use the StringInfo class.

Il n’existe aucun constructeur public pour CharEnumerator.There is no public constructor for CharEnumerator. Au lieu de cela, appelez la méthode GetEnumerator de l’objet String pour obtenir une CharEnumerator initialisée pour référencer la chaîne.Instead, call a String object's GetEnumerator method to obtain a CharEnumerator that is initialized to reference the string.

Un CharEnumerator conserve un index interne des caractères de la chaîne à laquelle le CharEnumerator fait référence.A CharEnumerator maintains an internal index to the characters in the string the CharEnumerator references. L’état de l’index n’est pas valide lorsqu’il fait référence à une position de caractère logiquement avant le premier caractère ou après le dernier caractère de la chaîne, et valide lorsqu’il référence un caractère dans la chaîne.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’index est initialisé à une position logiquement avant le premier caractère, et est défini sur une position après le dernier caractère lorsque l’itération est terminée.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. Une exception est levée si vous tentez d’accéder à un caractère alors que l’index n’est pas valide.An exception is thrown if you attempt to access a character while the index is invalid.

La méthode MoveNext incrémente l’index d’une unité, de sorte que le premier caractère et les caractères suivants sont accessibles tour à tour.The MoveNext method increments the index by one, so the first and subsequent characters are accessed in turn. La méthode Reset affecte logiquement à l’index une position avant le premier caractère.The Reset method sets the index to a position logically before the first character. La propriété Current récupère le caractère actuellement référencé par l’index.The Current property retrieves the character currently referenced by index. La méthode Clone crée une copie du CharEnumerator.The Clone method creates a copy of the CharEnumerator.

Notes

Plusieurs instances indépendantes de CharEnumerator sur un ou plusieurs threads peuvent avoir accès à une seule instance de String.Several independent instances of CharEnumerator across one or more threads can have access to a single instance of String. Cette classe est implémentée pour prendre en charge l’interface IEnumerator.This class is implemented to support the IEnumerator interface. Pour plus d’informations sur l’utilisation d’un énumérateur, consultez la rubrique IEnumerator.For more information regarding the use of an enumerator, see the IEnumerator topic.

Propriétés

Current

Obtient le caractère actuellement référencé dans la chaîne énumérée par cet objet CharEnumerator.Gets the currently referenced character in the string enumerated by this CharEnumerator object.

Méthodes

Clone()

Crée une copie de l'objet CharEnumerator en cours.Creates a copy of the current CharEnumerator object.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe CharEnumerator.Releases all resources used by the current instance of the CharEnumerator class.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MoveNext()

Incrémente l'index interne de l'objet CharEnumerator actuel jusqu'au caractère suivant de la chaîne énumérée.Increments the internal index of the current CharEnumerator object to the next character of the enumerated string.

Reset()

Initialise logiquement l'index à une position figurant avant le premier caractère de la chaîne énumérée.Initializes the index to a position logically before the first character of the enumerated string.

ToString()

Retourne une chaîne qui représente l'objet actif.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par la classe CharEnumerator.Releases all resources used by the CharEnumerator class.

IEnumerator.Current

Obtient le caractère actuellement référencé dans la chaîne énumérée par cet objet CharEnumerator.Gets the currently referenced character in the string enumerated by this CharEnumerator object. Pour obtenir une description de ce membre, consultez Current.For a description of this member, see Current.

S’applique à

Voir aussi