StringBuilder.Chars[Int32] Egenskap

Definition

Namnområde:

System.Text

Sammansättning:

mscorlib.dll

Hämtar eller anger tecknet på den angivna teckenpositionen i den här instansen.

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

Parametrar

index

Int32

Tecknets position.

Egenskapsvärde

Char

Unicode-tecknet på position index.

Undantag

ArgumentOutOfRangeException

index ligger utanför gränserna för den här instansen när du anger ett tecken.

IndexOutOfRangeException

index ligger utanför gränserna för den här instansen medan ett tecken hämtas.

Kommentarer

Parametern index är positionen för ett tecken i StringBuilder. Det första tecknet i strängen är vid index 0. Längden på en sträng är antalet tecken som den innehåller. Det sista tillgängliga tecknet för en StringBuilder instans är vid index Length - 1.

Chars[Int32] är standardegenskapen för StringBuilder klassen. I C# är det en indexerare. Det innebär att enskilda tecken kan hämtas från Chars[Int32] egenskapen enligt följande exempel, som räknar antalet alfabetiska tecken, blanksteg och skiljetecken i en sträng.

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

Det kan vara mycket långsamt att använda teckenbaserad indexering med Chars[] egenskapen under följande förhållanden:

• Instansen StringBuilder är stor (till exempel består den av flera tiotusentals tecken).
• Objektet StringBuilder är "chunky", det vill säga att upprepade anrop till metoder som StringBuilder.Append har automatiskt expanderat objektets StringBuilder.Capacity-egenskap och allokerat nya minnesblock till den.

Prestanda påverkas allvarligt eftersom varje teckenåtkomst går igenom hela den länkade listan med segment för att hitta rätt buffert att indexera i.

Note

Även för ett stort "chunky" StringBuilder -objekt har användning av Chars[] egenskapen för indexbaserad åtkomst till ett eller ett litet antal tecken en försumbar prestandapåverkan. Vanligtvis är det en O(n) åtgärd. Den betydande prestandapåverkan uppstår när tecknen i StringBuilder objektet itereras, vilket är en O(n^2) -åtgärd.

Om du får prestandaproblem när du använder teckenbaserad indexering med StringBuilder objekt kan du använda någon av följande lösningar:

• Konvertera instansen StringBuilder till en String genom att anropa ToString metoden och få sedan åtkomst till tecknen i strängen.

• Kopiera innehållet i det befintliga StringBuilder objektet till ett nytt förstoringsobjekt StringBuilder . Prestanda förbättras eftersom det nya StringBuilder objektet inte är segmentigt. Ett exempel:

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

• Ange objektets StringBuilder ursprungliga kapacitet till ett värde som är ungefär lika med den maximala förväntade storleken genom att anropa StringBuilder(Int32) konstruktorn. Observera att detta allokerar hela minnesblocket även om den StringBuilder sällan når sin maximala kapacitet.

Se även

• String