Partilhar via


StringBuilder.Chars[Int32] Propriedade

Definição

Obtém ou define o caractere na posição de caractere especificada nessa instância.

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

Parâmetros

index
Int32

A posição do caractere.

Valor da propriedade

O caractere Unicode na posição index.

Exceções

index está fora dos limites dessa instância ao definir um caractere.

index está fora dos limites dessa instância ao obter um caractere.

Comentários

O index parâmetro é a posição de um caractere dentro do StringBuilder. O primeiro caractere na cadeia de caracteres está no índice 0. O comprimento de uma cadeia de caracteres é o número de caracteres que ela contém. O último caractere acessível de uma StringBuilder instância está no índice Length - 1.

Chars[Int32] é a propriedade padrão da StringBuilder classe . Em C#, é um indexador. Isso significa que caracteres individuais podem ser recuperados da Chars[Int32] propriedade, conforme mostrado no exemplo a seguir, que conta o número de caracteres alfabéticos, de espaço em branco e de pontuação em uma cadeia de caracteres.

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

O uso da indexação baseada em caracteres com a propriedade Chars[] pode ser extremamente lento nas seguintes condições:

O desempenho é afetado gravemente porque cada acesso de caractere percorre toda a lista vinculada de partes para localizar o buffer correto ao qual indexar.

Observação

Mesmo para um objeto "volumoso" StringBuilder grande, usar a Chars[] propriedade para acesso baseado em índice a um ou um pequeno número de caracteres tem um impacto de desempenho insignificante; normalmente, é uma operação O(n). O impacto significativo sobre o desempenho ocorre ao iterar os caracteres no objeto StringBuilder, que é uma operação O(n^2).

Se encontrar problemas de desempenho ao usar a indexação baseada em caractere com objetos StringBuilder, você poderá usar qualquer uma das seguintes alternativas:

  • Converter a instância StringBuilder para um String chamando o método ToString e, em seguida, acessar os caracteres na cadeia de caracteres.

  • Copiar o conteúdo do objeto StringBuilder existente para um novo objeto StringBuilder pré-dimensionado. O desempenho melhora porque o novo objeto StringBuilder não é robusto. Por exemplo:

    // 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)
    
  • Definir a capacidade inicial do objeto StringBuilder como um valor aproximadamente igual ao seu tamanho máximo esperado chamando o construtor StringBuilder(Int32). Observe que isso aloca o bloco de memória inteiro mesmo que o StringBuilder raramente atinja sua capacidade máxima.

Aplica-se a

Confira também