CharEnumerator Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Unterstützt das Durchlaufen eines String-Objekts und Lesen seiner einzelnen Zeichen. Diese Klasse kann nicht vererbt werden.

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.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class CharEnumerator : ICloneable, System.Collections.Generic.IEnumerator<char>

type CharEnumerator = class
    interface IEnumerator<char>
    interface IEnumerator
    interface IDisposable
    interface ICloneable

[<System.Serializable>]
type CharEnumerator = class
    interface IEnumerator
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CharEnumerator = class
    interface ICloneable
    interface IEnumerator<char>
    interface IDisposable
    interface IEnumerator

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CharEnumerator = class
    interface ICloneable
    interface IEnumerator<char>
    interface IEnumerator
    interface IDisposable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
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

Vererbung: Object
CharEnumerator

Attribute: SerializableAttribute ComVisibleAttribute

Implementiert: IEnumerator<Char> IEnumerator ICloneable IDisposable

Beispiele

Im folgenden Beispiel wird die CharEnumerator -Klasse verwendet, um die einzelnen Zeichen in einer Zeichenfolge aufzulisten. Es instanziiert ein CharEnumerator -Objekt durch Aufrufen der String.GetEnumerator -Methode, wechselt von einem Zeichen zum nächsten durch Aufrufen der MoveNext -Methode und zeigt das aktuelle Zeichen an, indem der Wert der Current -Eigenschaft abgerufen wird.

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

let title = "A Tale of Two Cities"
let chEnum = title.GetEnumerator()

printfn $"The length of the string is {title.Length} characters:"

let mutable outputLine1 = ""
let mutable outputLine2 = ""
let mutable outputLine3 = ""
let mutable i = 1

while chEnum.MoveNext() do
    outputLine1 <- outputLine1 + if i < 10 || i % 10 <> 0 then "  " else $"{i / 10} "
    outputLine2 <- outputLine2 + $"{i % 10} ";
    outputLine3 <- outputLine3 + $"{chEnum.Current} "
    i <- i + 1

printfn "%s" outputLine1
printfn "%s" outputLine2
printfn "%s" 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

Beachten Sie jedoch, dass derselbe Vorgang etwas intuitiver foreach mit (in C#) oder For Each (in Visual Basic) ausgeführt werden kann, wie im folgenden Beispiel gezeigt.

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

let title = "A Tale of Two Cities"
let chEnum = title.GetEnumerator()

printfn $"The length of the string is {title.Length} characters:"

let mutable outputLine1 = ""
let mutable outputLine2 = ""
let mutable outputLine3 = ""
let mutable i = 1

for ch in title do
    outputLine1 <- outputLine1 + if i < 10 || i % 10 <> 0 then "  " else $"{i / 10} "
    outputLine2 <- outputLine2 + $"{i % 10} ";
    outputLine3 <- outputLine3 + $"{ch} "
    i <- i + 1

printfn "%s" outputLine1
printfn "%s" outputLine2
printfn "%s" 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

Hinweise

Ein CharEnumerator bietet schreibgeschützten Zugriff auf die Zeichen in einem Objekt, auf das verwiesen wird String . Beispielsweise ruft die foreach -Anweisung der Microsoft Programmiersprachen Visual Basic und C#, die die Elemente einer Auflistung durchläuft, aus einem -Objekt ab CharEnumerator String, um die Zeichen in diesem Objekt zu durchlaufen.

Wichtig

Die CharEnumerator -Klasse listet einzelne 16-Bit-Instanzen Char auf. Grapheme (d. h. ein Zeichen, auf das ein oder mehrere Kombinationszeichen folgen) oder Ersatzzeichenpaare (d. h. Zeichen außerhalb der mehrsprachigen Unicode-Basisebene) werden nicht als einzelne Zeichen betrachtet. Verwenden Sie für einen Enumerator, der diese Zeichentypen als einzelne Einheit behandelt, die StringInfo -Klasse.

Es gibt keinen öffentlichen Konstruktor für CharEnumerator. Rufen Sie stattdessen die -Methode eines String GetEnumerator -Objekts auf, um eine CharEnumerator abzurufen, die initialisiert wird, um auf die Zeichenfolge zu verweisen.

Ein CharEnumerator verwaltet einen internen Index für die Zeichen in der Zeichenfolge, auf die verwiesen wird CharEnumerator . Der Status des Indexes ist ungültig, wenn er auf eine Zeichenposition logisch vor dem ersten Zeichen oder nach dem letzten Zeichen in der Zeichenfolge verweist, und gültig, wenn er auf ein Zeichen innerhalb der Zeichenfolge verweist. Der Index wird logisch vor dem ersten Zeichen initialisiert und nach Abschluss der Iteration auf eine Position nach dem letzten Zeichen festgelegt. Eine Ausnahme wird ausgelöst, wenn Sie versuchen, auf ein Zeichen zuzugreifen, während der Index ungültig ist.

Die MoveNext -Methode erhöht den Index um eins, sodass wiederum auf das erste und nachfolgende Zeichen zugegriffen wird. Die Reset -Methode legt den Index logisch vor dem ersten Zeichen fest. Die Current -Eigenschaft ruft das Zeichen ab, auf das derzeit vom Index verwiesen wird. Die Clone -Methode erstellt eine Kopie von CharEnumerator.

Hinweis

Mehrere unabhängige Instanzen von CharEnumerator können über einen oder mehrere Threads hinweg Zugriff auf eine einzelne Instanz von Stringhaben. Diese Klasse wird implementiert, um die IEnumerator -Schnittstelle zu unterstützen. Weitere Informationen zur Verwendung eines Enumerators finden Sie im IEnumerator Thema.

Eigenschaften

Current

Ruft das Zeichen in der von diesem CharEnumerator-Objekt durchlaufenen Zeichenfolge ab, auf das zurzeit verwiesen wird.

Methoden

Clone()	Erstellt eine Kopie des aktuellen CharEnumerator-Objekts.
Dispose()	Gibt alle von der aktuellen Instanz der CharEnumerator-Klasse verwendeten Ressourcen frei.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MoveNext()	Inkrementiert den internen Index des aktuellen CharEnumerator-Objekts zum nächsten Zeichen der aufgelisteten Zeichenfolge.
Reset()	Initialisiert den Index auf eine Position, die sich logisch vor dem ersten Zeichen der aufgelisteten Zeichenfolge befindet.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()	Gibt alle von der CharEnumerator-Klasse verwendeten Ressourcen frei.
IEnumerator.Current	Ruft das Zeichen in der von diesem CharEnumerator-Objekt durchlaufenen Zeichenfolge ab, auf das zurzeit verwiesen wird. Eine Beschreibung dieses Elements finden Sie unter Current.

Gilt für: