StringBuilder.Chars[Int32] Eigenschap

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

Parameters

Waarde van eigenschap

Het Unicode-teken op positie index.

Uitzonderingen

Opmerkingen

De index parameter is de positie van een teken binnen het StringBuilderteken . Het eerste teken in de tekenreeks bevindt zich op index 0. De lengte van een tekenreeks is het aantal tekens dat de tekenreeks bevat. Het laatste toegankelijke teken van een StringBuilder exemplaar bevindt zich in index Length - 1.

Chars[Int32] is de standaardeigenschap van de StringBuilder klasse. In C# is het een indexeerfunctie. Dit betekent dat afzonderlijke tekens kunnen worden opgehaald uit de Chars[Int32] eigenschap, zoals wordt weergegeven in het volgende voorbeeld, waarmee het aantal alfabetische, witruimte en interpunctietekens in een tekenreeks wordt geteld.

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

Het gebruik van indexering op basis van tekens met de Chars[] eigenschap kan zeer traag zijn onder de volgende omstandigheden:

• Het StringBuilder exemplaar is groot (bijvoorbeeld uit meerdere tienduizenden tekens).
• Het StringBuilder is 'chunky'. Met andere woorden, herhaalde aanroepen naar methoden zoals StringBuilder.Append hebben automatisch de StringBuilder.Capacity eigenschap van het object uitgebreid en nieuwe chunks geheugen aan het object toegewezen.

De prestaties zijn ernstig van invloed omdat elke tekentoegang de volledige gekoppelde lijst met segmenten doorloopt om de juiste buffer te vinden om in te indexeren.

Als u prestatieproblemen ondervindt bij het gebruik van indexering op basis van tekens met StringBuilder objecten, kunt u een van de volgende tijdelijke oplossingen gebruiken:

• Converteer het StringBuilder exemplaar naar een String door de ToString methode aan te roepen en benader vervolgens de tekens in de tekenreeks.

• Kopieer de inhoud van het bestaande StringBuilder object naar een nieuw, vooraf bepaald formaat StringBuilder object. De prestaties worden verbeterd omdat het nieuwe StringBuilder object niet chunky is. Voorbeeld:

  // 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)
  

• Stel de initiële capaciteit van het StringBuilder object in op een waarde die ongeveer gelijk is aan de maximale verwachte grootte door de StringBuilder(Int32) constructor aan te roepen. Houd er rekening mee dat hiermee het hele geheugenblok wordt toegewezen, zelfs als de StringBuilder maximale capaciteit zelden wordt bereikt.

Zie ook

• String