StringBuilder.Chars[Int32] Proprietà

Definizione

Spazio dei nomi:

System.Text

Assembly:

System.Runtime.dll

Origine:

StringBuilder.cs

Ottiene o imposta il carattere nella posizione del carattere specificata in questa istanza.

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

Parametri

index

Int32

Posizione del carattere.

Valore della proprietà

Char

Carattere Unicode nella posizione index.

Eccezioni

ArgumentOutOfRangeException

index non è compreso nei limiti dell'istanza durante l'impostazione di un carattere.

IndexOutOfRangeException

index non è compreso nei limiti dell'istanza durante l'ottenimento di un carattere.

Commenti

Il index parametro è la posizione di un carattere all'interno di StringBuilder. Il primo carattere nella stringa è in corrispondenza dell'indice 0. La lunghezza di una stringa è il numero di caratteri che contiene. L'ultimo carattere accessibile di un'istanza StringBuilder è in corrispondenza dell'indice Length - 1.

Chars[Int32] è la proprietà predefinita della StringBuilder classe . In C#, si tratta di un indicizzatore. Ciò significa che i singoli caratteri possono essere recuperati dalla Chars[Int32] proprietà come illustrato nell'esempio seguente, che conta il numero di caratteri alfabetici, spazi vuoti e punteggiatura in una stringa.

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

L'uso dell'indicizzazione basata sui caratteri con la proprietà Chars[] può essere lentissimo nelle condizioni seguenti:

• L'istanza StringBuilder è di grandi dimensioni (ad esempio, è costituita da diverse decine di migliaia di caratteri).
• Il StringBuilder è "in blocchi". Ovvero, le chiamate ripetute ai metodi, ad StringBuilder.Append esempio, hanno espanso automaticamente la proprietà dell'oggetto StringBuilder.Capacity e allocato nuovi blocchi di memoria.

L'impatto sulle prestazioni è notevole poiché ogni accesso ai caratteri scorre l'intero elenco di blocchi collegato per trovare il buffer corretto in cui eseguire l'indicizzazione.

Nota

Anche per un oggetto "in blocchi" StringBuilder di grandi dimensioni, l'utilizzo della Chars[] proprietà per l'accesso basato su indice a uno o un numero ridotto di caratteri ha un impatto trascurabile sulle prestazioni. In genere, si tratta di un'operazione O(n). L'impatto significativo sulle prestazioni si verifica durante l'iterazione dei caratteri nell'oggetto StringBuilder, che è un'operazione O(n^2).

Se si verificano problemi di prestazioni quando si usa l'indicizzazione basata su caratteri con gli oggetti StringBuilder, è possibile adottare una delle seguenti soluzioni alternative:

• Convertire l'istanza StringBuilder in un String chiamando il metodo ToString, quindi accedere ai caratteri nella stringa.

• Copiare il contenuto dell'oggetto StringBuilder esistente in un nuovo oggetto StringBuilder con dimensioni preimpostate. Le prestazioni migliorano perché il nuovo oggetto StringBuilder non è pesante. Ad esempio:

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

• Impostare la capacità iniziale dell'oggetto StringBuilder su un valore approssimativamente uguale alle dimensioni massime previste chiamando il costruttore StringBuilder(Int32). Si noti che in questo modo viene allocato l'intero di memoria anche se StringBuilder raramente raggiunge la capacità massima.

Vedi anche

• String