StringBuilder.Chars[Int32] Eigenschaft

Definition

Namespace:

System.Text

Assembly:

System.Runtime.dll

Quelle:

StringBuilder.cs

Ruft das Zeichen an der angegebenen Zeichenposition in dieser Instanz ab oder legt dieses fest.

public:
 property char default[int] { char get(int index); void set(int index, char value); };

public char this[int index] { get; set; }

member this.Chars(int) : char with get, set

Default Public Property Chars(index As Integer) As Char

Parameter

index

Int32

Die Position des Zeichens.

Eigenschaftswert

Char

Das Unicode-Zeichen an der Position index.

Ausnahmen

ArgumentOutOfRangeException

index liegt beim Festlegen eines Zeichens außerhalb des Bereichs dieser Instanz.

IndexOutOfRangeException

index liegt beim Abrufen eines Zeichens außerhalb des Bereichs dieser Instanz.

Hinweise

Der index Parameter ist die Position eines Zeichens innerhalb des StringBuilder. Das erste Zeichen in der Zeichenfolge befindet sich bei Index 0. Die Länge einer Zeichenfolge ist die Anzahl von Zeichen, die sie enthält. Das letzte zugängliche Zeichen eines StringBuilder instance befindet sich bei index Length - 1.

Chars[Int32] ist die Standardeigenschaft der StringBuilder -Klasse. In C# handelt es sich um einen Indexer. Dies bedeutet, dass einzelne Zeichen aus der Chars[Int32] -Eigenschaft abgerufen werden können, wie im folgenden Beispiel gezeigt, das die Anzahl der alphabetischen Zeichen, Leerzeichen und Interpunktionszeichen in einer Zeichenfolge zählt.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      int nAlphabeticChars = 0;
      int nWhitespace = 0;
      int nPunctuation = 0;  
      StringBuilder sb = new StringBuilder("This is a simple sentence.");
      
      for (int ctr = 0; ctr < sb.Length; ctr++) {
         char ch = sb[ctr];
         if (Char.IsLetter(ch)) { nAlphabeticChars++;  continue; }
         if (Char.IsWhiteSpace(ch)) { nWhitespace++;  continue; }
         if (Char.IsPunctuation(ch)) nPunctuation++;  
      }    

      Console.WriteLine("The sentence '{0}' has:", sb);
      Console.WriteLine("   Alphabetic characters: {0}", nAlphabeticChars);
      Console.WriteLine("   White-space characters: {0}", nWhitespace);
      Console.WriteLine("   Punctuation characters: {0}", nPunctuation);
   }
}
// The example displays the following output:
//       The sentence 'This is a simple sentence.' has:
//          Alphabetic characters: 21
//          White-space characters: 4
//          Punctuation characters: 1

open System
open System.Text

let mutable nAlphabeticChars = 0
let mutable nWhitespace = 0
let mutable nPunctuation = 0  
let sb = StringBuilder "This is a simple sentence."

for i = 0 to sb.Length - 1 do
    let ch = sb[i]
    if Char.IsLetter ch then
        nAlphabeticChars <- nAlphabeticChars + 1
    elif Char.IsWhiteSpace ch then
        nWhitespace <- nWhitespace + 1
    elif Char.IsPunctuation ch then
        nPunctuation <- nPunctuation + 1

printfn $"The sentence '{sb}' has:"
printfn $"   Alphabetic characters: {nAlphabeticChars}"
printfn $"   White-space characters: {nWhitespace}"
printfn $"   Punctuation characters: {nPunctuation}"

// The example displays the following output:
//       The sentence 'This is a simple sentence.' has:
//          Alphabetic characters: 21
//          White-space characters: 4
//          Punctuation characters: 1

Imports System.Text

Module Example
   Public Sub Main()
      Dim nAlphabeticChars As Integer = 0
      Dim nWhitespace As Integer = 0
      Dim nPunctuation As Integer = 0  
      Dim sb As New StringBuilder("This is a simple sentence.")
      
      For ctr As Integer = 0 To sb.Length - 1
         Dim ch As Char = sb(ctr)
         If Char.IsLetter(ch) Then nAlphabeticChars += 1 : Continue For
         If Char.IsWhiteSpace(ch) Then nWhitespace += 1 : Continue For
         If Char.IsPunctuation(ch) Then nPunctuation += 1
      Next    

      Console.WriteLine("The sentence '{0}' has:", sb)
      Console.WriteLine("   Alphabetic characters: {0}", nAlphabeticChars)
      Console.WriteLine("   White-space characters: {0}", nWhitespace)
      Console.WriteLine("   Punctuation characters: {0}", nPunctuation)
   End Sub
End Module
' The example displays the following output:
'       The sentence 'This is a simple sentence.' has:
'          Alphabetic characters: 21
'          White-space characters: 4
'          Punctuation characters: 1

Das Verwenden von zeichenbasierter Indizierung mit der Chars[]-Eigenschaft kann unter folgenden Bedingungen sehr langsam sein:

• Die StringBuilder-Instanz ist groß, weil sie beispielsweise aus Zehntausenden von Zeichen besteht.
• Die StringBuilder ist "chunky". Das heißt, wiederholte Aufrufe von Methoden wie StringBuilder.Append haben die Eigenschaft des StringBuilder.Capacity Objekts automatisch erweitert und ihm neue Speicherblöcke zugewiesen.

Die Leistung wird erheblich beeinträchtigt, da für jeden Zugriff auf ein Zeichen die gesamte verknüpfte Liste der Blöcke durchlaufen wird, um den richtigen Puffer für die Indizierung zu suchen.

Hinweis

Selbst bei einem großen "blockigen" StringBuilder Objekt hat die Verwendung der -Eigenschaft für den Chars[] indexbasierten Zugriff auf ein oder eine kleine Anzahl von Zeichen eine vernachlässigbare Auswirkung auf die Leistung. In der Regel handelt es sich um einen O(n) -Vorgang. Diese erheblichen Auswirkungen auf die Leistung treten auf, wenn die Zeichen im StringBuilder-Objekt durchlaufen werden. Dabei handelt es sich um eine O(n^2)-Operation.

Wenn Leistungsprobleme auftreten, wenn Sie die zeichenbasierte Indizierung mit StringBuilder-Objekten verwenden, können Sie eine der folgenden Problemumgehungen anwenden:

• Konvertieren Sie die StringBuilder-Instanz zu String, indem Sie die ToString-Methode aufrufen. Greifen Sie dann auf die Zeichen in der Zeichenfolge zu.

• Kopieren Sie die Inhalte des vorhandenen StringBuilder-Objekts in ein neues StringBuilder-Objekt mit vorab festgelegter Größe. Die Leistung verbessert sich, da das neue StringBuilder-Objekt nicht „blockweise“ strukturiert ist. Beispiel:

  // sbOriginal is the existing StringBuilder object
  var sbNew = new StringBuilder(sbOriginal.ToString(), sbOriginal.Length);
  

  ' sbOriginal is the existing StringBuilder object
  Dim sbNew = New StringBuilder(sbOriginal.ToString(), sbOriginal.Length)
  

• Legen Sie die anfängliche Kapazität des StringBuilder-Objekts auf einen Wert fest, der ungefähr der maximal erwarteten Größe entspricht, indem der StringBuilder(Int32)-Konstruktor aufgerufen wird. Beachten Sie, dass dadurch der gesamte Arbeitsspeicherblock zugeordnet wird, auch wenn StringBuilder selten die maximale Kapazität erreicht.

Weitere Informationen

• String