StringBuilder.Chars[Int32] Vlastnost

Definice

Obor názvů:

System.Text

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

StringBuilder.cs

Získá nebo nastaví znak na určené pozici znaku v této instanci.

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

Parametry

index

Int32

Pozice znaku.

Hodnota vlastnosti

Char

Znak Unicode na pozici index.

Výjimky

ArgumentOutOfRangeException

index je mimo hranice této instance při nastavování znaku.

IndexOutOfRangeException

index je mimo hranice této instance při získávání znaku.

Poznámky

Parametr index je pozice znaku v objektu StringBuilder. První znak v řetězci je v indexu 0. Délka řetězce je počet znaků, které obsahuje. Poslední přístupný znak StringBuilder instance je v indexu Length - 1.

Chars[Int32] je výchozí vlastnost StringBuilder třídy. V jazyce C# se jedná o indexer. To znamená, že jednotlivé znaky lze načíst z Chars[Int32] vlastnosti, jak je znázorněno v následujícím příkladu, což spočítá počet abecedních, prázdných a interpunkčních znaků v řetězci.

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

Použití indexování na základě znaků s Chars[] vlastností může být extrémně pomalé za následujících podmínek:

• Instance StringBuilder je velká (například se skládá z několika desítek tisíc znaků).
• Je StringBuilder to "chunky". To znamená, že opakovaná volání metod, například jako StringBuilder.Append, automaticky rozšířila vlastnost objektu StringBuilder.Capacity a přidělila jí nové bloky paměti.

Výkon je výrazně ovlivněn, protože každý přístup ke znakům prochází celý propojený seznam bloků, aby našel správnou vyrovnávací paměť pro indexování.

Note

I u velkého objektu "chunky" StringBuilder má použití Chars[] vlastnosti pro přístup na základě indexu k jednomu nebo malému počtu znaků zanedbatelný dopad na výkon. Obvykle se jedná o operaci O(n ). K významnému dopadu na výkon dochází při iterování znaků v objektuStringBuilder, což je operace O(n^2).

Pokud při použití indexování na základě znaků s StringBuilder objekty narazíte na problémy s výkonem, můžete použít některé z následujících alternativních řešení:

• StringBuilder Převeďte instanci na String voláním ToString metody a pak získejte přístup ke znakům v řetězci.

• Zkopírujte obsah existujícího StringBuilder objektu do nového předpřipraveného StringBuilder objektu. Výkon se zlepšuje, protože nový StringBuilder objekt není chunkvý. Příklad:

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

• Nastavte počáteční kapacitu objektu StringBuilder na hodnotu, která se přibližně rovná maximální očekávané velikosti voláním konstruktoru StringBuilder(Int32) . Všimněte si, že tím se přidělí celý blok paměti, i když StringBuilder zřídka dosáhne maximální kapacity.

Viz také

• String