StringBuilder.Chars[Int32] Propiedad

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

Valor de propiedad

Carácter Unicode en la posición index.

Excepciones

Comentarios

El index parámetro es la posición de un carácter dentro de StringBuilder. El primer carácter de la cadena está en el índice 0. La longitud de una cadena es el número de caracteres que contiene. El último carácter accesible de una StringBuilder instancia está en el índice Length - 1.

Chars[Int32] es la propiedad predeterminada de la StringBuilder clase . En C#, es un indexador. Esto significa que se pueden recuperar caracteres individuales de la Chars[Int32] propiedad como se muestra en el ejemplo siguiente, que cuenta el número de caracteres alfabéticos, espacios en blanco y signos de puntuación en una cadena.

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

El uso de la indexación basada en caracteres con la propiedad Chars[] puede ser muy lento en las condiciones siguientes:

• La instancia de StringBuilder es grande (por ejemplo, consta de varias decenas de miles de caracteres).
• StringBuilder es "fragmentado". Es decir, las llamadas repetidas a métodos, comoStringBuilder.Append, por ejemplo, han expandido automáticamente la propiedad del StringBuilder.Capacity objeto y le han asignado nuevos fragmentos de memoria.

El rendimiento se ve seriamente afectado ya que cada acceso de carácter recorre toda la lista vinculada de fragmentos para buscar el búfer correcto en el que indexar.

Si encuentra problemas de rendimiento al usar la indexación basada en caracteres con objetos StringBuilder, puede usar cualquiera de las soluciones alternativas siguientes:

• Convertir la instancia de StringBuilder en una String mediante una llamada al método ToString y después obtener acceso a los caracteres de la cadena.

• Copiar el contenido del objeto StringBuilder existente en un objeto StringBuilder nuevo de tamaño predefinido. El rendimiento mejora porque el objeto StringBuilder nuevo no es pesado. Por ejemplo:

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

• Establezca la capacidad inicial del objeto StringBuilder en un valor que sea aproximadamente igual a su tamaño máximo esperado mediante una llamada al constructor StringBuilder(Int32). Tenga en cuenta que esto asigna el bloque completo de memoria aunque StringBuilder rara vez alcanza su capacidad máxima.

Se aplica a

Consulte también

• String