StringBuilder Clase

Definición

Representa una cadena de caracteres mutable. Esta clase no puede heredarse.

public ref class StringBuilder sealed
public ref class StringBuilder sealed : System::Runtime::Serialization::ISerializable
public sealed class StringBuilder
public sealed class StringBuilder : System.Runtime.Serialization.ISerializable
[System.Serializable]
public sealed class StringBuilder
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class StringBuilder : System.Runtime.Serialization.ISerializable
type StringBuilder = class
type StringBuilder = class
    interface ISerializable
[<System.Serializable>]
type StringBuilder = class
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type StringBuilder = class
    interface ISerializable
Public NotInheritable Class StringBuilder
Public NotInheritable Class StringBuilder
Implements ISerializable
Herencia
StringBuilder
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo llamar a muchos de los métodos definidos por la StringBuilder clase .

using namespace System;
using namespace System::Text;

int main()
{
    // Create a StringBuilder that expects to hold 50 characters.
    // Initialize the StringBuilder with "ABC".
    StringBuilder^ sb = gcnew StringBuilder("ABC", 50);

    // Append three characters (D, E, and F) to the end of the
    // StringBuilder.
    sb->Append(gcnew array<Char>{'D', 'E', 'F'});

    // Append a format string to the end of the StringBuilder.
    sb->AppendFormat("GHI{0}{1}", (Char)'J', (Char)'k');

    // Display the number of characters in the StringBuilder
    // and its string.
    Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());

    // Insert a string at the beginning of the StringBuilder.
    sb->Insert(0, "Alphabet: ");

    // Replace all lowercase k's with uppercase K's.
    sb->Replace('k', 'K');

    // Display the number of characters in the StringBuilder
    // and its string.
    Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());
}

// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
using System;
using System.Text;

public sealed class App
{
    static void Main()
    {
        // Create a StringBuilder that expects to hold 50 characters.
        // Initialize the StringBuilder with "ABC".
        StringBuilder sb = new StringBuilder("ABC", 50);

        // Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(new char[] { 'D', 'E', 'F' });

        // Append a format string to the end of the StringBuilder.
        sb.AppendFormat("GHI{0}{1}", 'J', 'k');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());

        // Insert a string at the beginning of the StringBuilder.
        sb.Insert(0, "Alphabet: ");

        // Replace all lowercase k's with uppercase K's.
        sb.Replace('k', 'K');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
    }
}

// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
Imports System.Text

Public Module App 
    Public Sub Main() 
        ' Create a StringBuilder that expects to hold 50 characters.
        ' Initialize the StringBuilder with "ABC".
        Dim sb As New StringBuilder("ABC", 50)

        ' Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(New Char() {"D"c, "E"c, "F"c})

        ' Append a format string to the end of the StringBuilder.
        sb.AppendFormat("GHI{0}{1}", "J"c, "k"c)

        ' Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())

        ' Insert a string at the beginning of the StringBuilder.
        sb.Insert(0, "Alphabet: ")

        ' Replace all lowercase k's with uppercase K's.
        sb.Replace("k", "K")

        ' Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())
    End Sub
End Module

' This code produces the following output.
'
' 11 chars: ABCDEFGHIJk
' 21 chars: Alphabet: ABCDEFGHIJK

Comentarios

Esta clase representa un objeto similar a cadena cuyo valor es una secuencia mutable de caracteres.

En esta sección:

Los tipos String y StringBuilder

Aunque StringBuilder y String ambos representan secuencias de caracteres, se implementan de forma diferente. String es un tipo inmutable. Es decir, cada operación que parece modificar un String objeto crea realmente una nueva cadena.

Por ejemplo, la llamada al String.Concat método en el ejemplo de C# siguiente parece cambiar el valor de una variable de cadena denominada value. De hecho, el Concat método devuelve un value objeto que tiene un valor y una dirección diferentes del value objeto que se pasó al método . Tenga en cuenta que el ejemplo debe compilarse con la /unsafe opción del compilador.

using System;

public class Example
{
   public unsafe static void Main()
   {
      string value = "This is the first sentence" + ".";
      fixed (char* start = value)
      {
         value = String.Concat(value, "This is the second sentence. ");
         fixed (char* current = value)
         {
            Console.WriteLine(start == current);
         }
      }   
   }
}
// The example displays the following output:
//      False

En el caso de las rutinas que realizan una manipulación extensa de cadenas (como las aplicaciones que modifican una cadena varias veces en un bucle), modificar una cadena repetidamente puede aplicar una penalización significativa del rendimiento. La alternativa es usar StringBuilder, que es una clase de cadena mutable. La mutabilidad significa que, una vez creada una instancia de la clase, se puede modificar anexando, quitando, reemplazando o insertando caracteres. Un StringBuilder objeto mantiene un búfer para acomodar las expansiones a la cadena. Los nuevos datos se anexan al búfer si la sala está disponible; de lo contrario, se asigna un nuevo búfer más grande, los datos del búfer original se copian en el nuevo búfer y los nuevos datos se anexan al nuevo búfer.

Importante

Aunque la StringBuilder clase generalmente ofrece un mejor rendimiento que la String clase , no debe reemplazar String StringBuilder automáticamente por cada vez que quiera manipular cadenas. El rendimiento depende del tamaño de la cadena, la cantidad de memoria que se asignará para la nueva cadena, el sistema en el que se ejecuta el código y el tipo de operación. Debe estar preparado para probar el código para determinar si StringBuilder realmente ofrece una mejora significativa del rendimiento.

Considere la posibilidad de usar la String clase en estas condiciones:

  • Cuando el número de cambios que realizará el código en una cadena es pequeño. En estos casos, StringBuilder puede ofrecer una mejora insignificante o ninguna mejora del rendimiento sobre String.

  • Al realizar un número fijo de operaciones de concatenación, especialmente con literales de cadena. En este caso, el compilador podría combinar las operaciones de concatenación en una sola operación.

  • Cuando tenga que realizar operaciones de búsqueda extensas mientras compila la cadena. La StringBuilder clase carece de métodos de búsqueda como IndexOf o StartsWith. Tendrá que convertir el StringBuilder objeto en para String estas operaciones y esto puede negar la ventaja de rendimiento del uso StringBuilderde . Para obtener más información, vea la sección Búsqueda del texto en un objeto StringBuilder .

Considere la posibilidad de usar la StringBuilder clase en estas condiciones:

  • Cuando se espera que el código realice un número desconocido de cambios en una cadena en tiempo de diseño (por ejemplo, cuando se usa un bucle para concatenar un número aleatorio de cadenas que contienen la entrada del usuario).

  • Cuando se espera que el código realice un número significativo de cambios en una cadena.

Funcionamiento de StringBuilder

La StringBuilder.Length propiedad indica el número de caracteres que contiene el StringBuilder objeto actualmente. Si agrega caracteres al StringBuilder objeto, su longitud aumenta hasta que es igual al tamaño de la StringBuilder.Capacity propiedad , que define el número de caracteres que el objeto puede contener. Si el número de caracteres agregados hace que la longitud del StringBuilder objeto supere su capacidad actual, se asigna nueva memoria, se duplica el valor de la Capacity propiedad, se agregan nuevos caracteres al StringBuilder objeto y se ajusta su Length propiedad. La memoria adicional para el StringBuilder objeto se asigna dinámicamente hasta que alcanza el valor definido por la StringBuilder.MaxCapacity propiedad . Cuando se alcanza la capacidad máxima, no se puede asignar más memoria para el StringBuilder objeto e intentar agregar caracteres o expandirla más allá de su capacidad máxima produce una ArgumentOutOfRangeException excepción o .OutOfMemoryException

En el ejemplo siguiente se muestra cómo un StringBuilder objeto asigna nueva memoria y aumenta su capacidad dinámicamente a medida que se expande la cadena asignada al objeto. El código crea un StringBuilder objeto llamando a su constructor predeterminado (sin parámetros). La capacidad predeterminada de este objeto es de 16 caracteres y su capacidad máxima es de más de 2 mil millones de caracteres. Anexando la cadena "This is a sentence". da como resultado una nueva asignación de memoria porque la longitud de cadena (19 caracteres) supera la capacidad predeterminada del StringBuilder objeto. La capacidad del objeto se duplica en 32 caracteres, se agrega la nueva cadena y la longitud del objeto ahora es igual a 19 caracteres. A continuación, el código anexa la cadena "This is an additional sentence". al valor del StringBuilder objeto 11 veces. Cada vez que la operación append hace que la longitud del StringBuilder objeto supere su capacidad, se duplica su capacidad existente y la Append operación se realiza correctamente.

using System;
using System.Reflection;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder();
      ShowSBInfo(sb);
      sb.Append("This is a sentence.");
      ShowSBInfo(sb);
      for (int ctr = 0; ctr <= 10; ctr++) {
         sb.Append("This is an additional sentence.");
         ShowSBInfo(sb);
      }   
   }
   
   private static void ShowSBInfo(StringBuilder sb)
   {
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
//    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
//    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360
Imports System.Reflection
Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder()
      ShowSBInfo(sb)
      sb.Append("This is a sentence.")
      ShowSbInfo(sb)
      For ctr As Integer = 0 To 10
         sb.Append("This is an additional sentence.")
         ShowSbInfo(sb)
      Next   
   End Sub
   
   Public Sub ShowSBInfo(sb As StringBuilder)
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
'    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
'    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
'    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
'    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
'    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
'    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360

Asignación de memoria

La capacidad predeterminada de un StringBuilder objeto es de 16 caracteres y su capacidad máxima predeterminada es Int32.MaxValue. Estos valores predeterminados se usan si se llama a los StringBuilder() constructores y StringBuilder(String) .

Puede definir explícitamente la capacidad inicial de un StringBuilder objeto de las siguientes maneras:

  • Llamando a cualquiera de los StringBuilder constructores que incluye un capacity parámetro al crear el objeto .

  • Al asignar explícitamente un nuevo valor a la StringBuilder.Capacity propiedad para expandir un objeto existente StringBuilder . Tenga en cuenta que la propiedad produce una excepción si la nueva capacidad es menor que la capacidad existente o mayor que la StringBuilder capacidad máxima del objeto.

  • Llamando al StringBuilder.EnsureCapacity método con la nueva capacidad. La nueva capacidad no debe ser mayor que la StringBuilder capacidad máxima del objeto. Sin embargo, a diferencia de una asignación a la Capacity propiedad , EnsureCapacity no produce una excepción si la nueva capacidad deseada es menor que la capacidad existente; en este caso, la llamada al método no tiene ningún efecto.

Si la longitud de la cadena asignada al StringBuilder objeto en la llamada del constructor supera la capacidad predeterminada o la capacidad especificada, la Capacity propiedad se establece en la longitud de la cadena especificada con el value parámetro .

Puede definir explícitamente la capacidad máxima de un StringBuilder objeto llamando al StringBuilder(Int32, Int32) constructor . No se puede cambiar la capacidad máxima asignando un nuevo valor a la MaxCapacity propiedad , ya que es de solo lectura.

Como se muestra en la sección anterior, cada vez que la capacidad existente no es adecuada, se asigna memoria adicional y la capacidad de un StringBuilder objeto se duplica hasta el valor definido por la MaxCapacity propiedad .

En general, la capacidad predeterminada y la capacidad máxima son adecuadas para la mayoría de las aplicaciones. Puede considerar la posibilidad de establecer estos valores en las siguientes condiciones:

  • Si es probable que el tamaño final del StringBuilder objeto crezca demasiado grande, normalmente en exceso de varios megabytes. En este caso, puede haber algunas ventajas de rendimiento al establecer la propiedad inicial Capacity en un valor significativamente alto para eliminar la necesidad de demasiadas reasignaciones de memoria.

  • Si el código se ejecuta en un sistema con memoria limitada. En este caso, es posible que quiera considerar la posibilidad de establecer la MaxCapacity propiedad en menor que Int32.MaxValue si el código controla cadenas grandes que pueden hacer que se ejecute en un entorno con restricciones de memoria.

Creación de instancias de un objeto StringBuilder

Cree una instancia de un StringBuilder objeto llamando a uno de sus seis constructores de clase sobrecargados, que se enumeran en la tabla siguiente. Tres de los constructores crean instancias de un StringBuilder objeto cuyo valor es una cadena vacía, pero establecen sus Capacity valores y MaxCapacity de forma diferente. Los tres constructores restantes definen un StringBuilder objeto que tiene un valor de cadena y una capacidad específicos. Dos de los tres constructores usan la capacidad máxima predeterminada de Int32.MaxValue, mientras que la tercera le permite establecer la capacidad máxima.

Constructor Valor de cadena Capacity Capacidad máxima
StringBuilder() String.Empty 16 Int32.MaxValue
StringBuilder(Int32) String.Empty Definido por el capacity parámetro Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Definido por el capacity parámetro Definido por el maxCapacity parámetro
StringBuilder(String) Definido por el value parámetro 16 o value. Length, lo que sea mayor Int32.MaxValue
StringBuilder(String, Int32) Definido por el value parámetro Definido por el capacity parámetro o value. Length, lo que sea mayor. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) Definido por value. Substring(startIndex, length) Definido por el capacity parámetro o value. Length, lo que sea mayor. Int32.MaxValue

En el ejemplo siguiente se usan tres de estas sobrecargas de constructor para crear StringBuilder instancias de objetos.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      string value = "An ordinary string";
      int index = value.IndexOf("An ") + 3;
      int capacity = 0xFFFF;
      
      // Instantiate a StringBuilder from a string.
      StringBuilder sb1 = new StringBuilder(value);
      ShowSBInfo(sb1); 
      
      // Instantiate a StringBuilder from string and define a capacity.  
      StringBuilder sb2 = new StringBuilder(value, capacity);   
      ShowSBInfo(sb2); 
      
      // Instantiate a StringBuilder from substring and define a capacity.  
      StringBuilder sb3 = new StringBuilder(value, index, 
                                            value.Length - index, 
                                            capacity );
      ShowSBInfo(sb3); 
   }

   public static void ShowSBInfo(StringBuilder sb)
   {
      Console.WriteLine("\nValue: {0}", sb.ToString());
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Value: An ordinary string
//    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: An ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15
Imports System.Text

Module Example
   Public Sub Main()
      Dim value As String = "An ordinary string"
      Dim index As Integer = value.IndexOf("An ") + 3
      Dim capacity As Integer = &hFFFF
      
      ' Instantiate a StringBuilder from a string.
      Dim sb1 As New StringBuilder(value)
      ShowSBInfo(sb1) 
      
      ' Instantiate a StringBuilder from string and define a capacity.  
      Dim sb2 As New StringBuilder(value, capacity)   
      ShowSBInfo(sb2) 
      
      ' Instantiate a StringBuilder from substring and define a capacity.  
      Dim sb3 As New StringBuilder(value, index, 
                                   value.Length - index, 
                                   capacity )
      ShowSBInfo(sb3) 
   End Sub
   
   Public Sub ShowSBInfo(sb As StringBuilder)
      Console.WriteLine()
      Console.WriteLine("Value: {0}", sb.ToString())
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Value: An ordinary string
'    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
'    
'    Value: An ordinary string
'    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
'    
'    Value: ordinary string
'    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15

Llamar a los métodos stringBuilder

La mayoría de los métodos que modifican la cadena de una StringBuilder instancia devuelven una referencia a esa misma instancia. Esto le permite llamar StringBuilder a métodos de dos maneras:

  • Puede realizar llamadas de método individuales y omitir el valor devuelto, como hace el ejemplo siguiente.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          StringBuilder sb = new StringBuilder();
          sb.Append("This is the beginning of a sentence, ");
          sb.Replace("the beginning of ", "");
          sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ");
          sb.Replace(",", ".");
          Console.WriteLine(sb.ToString());
       }
    }
    // The example displays the following output:
    //        This is a complete sentence.
    
    Imports System.Text
    
    Module Example
       Public Sub Main()
          Dim sb As New StringBuilder()
          sb.Append("This is the beginning of a sentence, ")
          sb.Replace("the beginning of ", "")
          sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ")
          sb.Replace(",", ".")
          Console.WriteLine(sb.ToString())
       End Sub
    End Module
    ' The example displays the following output:
    '       This is a complete sentence.
    
  • Puede realizar una serie de llamadas de método en una sola instrucción. Esto puede ser cómodo si desea escribir una sola instrucción que encadene operaciones sucesivas. En el ejemplo siguiente se consolidan tres llamadas de método del ejemplo anterior en una sola línea de código.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          StringBuilder sb = new StringBuilder("This is the beginning of a sentence, ");
          sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2, 
                                                     "complete ").Replace(",", ".");
          Console.WriteLine(sb.ToString());
       }
    }
    // The example displays the following output:
    //        This is a complete sentence.
    
    Imports System.Text
    
    Module Example
       Public Sub Main()
          Dim sb As New StringBuilder("This is the beginning of a sentence, ")
          sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2, _
                                                     "complete ").Replace(", ", ".")
          Console.WriteLine(sb.ToString())
       End Sub
    End Module
    ' The example displays the following output:
    '       This is a complete sentence.
    

Realización de operaciones de StringBuilder

Puede usar los métodos de la StringBuilder clase para iterar, agregar, eliminar o modificar caracteres en un StringBuilder objeto .

Iteración de caracteres stringBuilder

Puede tener acceso a los caracteres de un StringBuilder objeto mediante la StringBuilder.Chars[] propiedad . En C#, Chars[] es un indexador; en Visual Basic, es la propiedad predeterminada de la StringBuilder clase . Esto le permite establecer o recuperar caracteres individuales mediante su índice solo, sin hacer referencia explícita a la Chars[] propiedad . Los caracteres de un StringBuilder objeto comienzan en el índice 0 (cero) y continúan indexando Length : 1.

En el ejemplo siguiente se muestra la Chars[] propiedad . Anexa diez números aleatorios a un StringBuilder objeto y, a continuación, itera cada carácter. Si la categoría Unicode del carácter es UnicodeCategory.DecimalDigitNumber, reduce el número en 1 (o cambia el número a 9 si su valor es 0). En el ejemplo se muestra el contenido del StringBuilder objeto antes y después de cambiar los valores de caracteres individuales.

using System;
using System.Globalization;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      
      // Generate 10 random numbers and store them in a StringBuilder.
      for (int ctr = 0; ctr <= 9; ctr++)
         sb.Append(rnd.Next().ToString("N5"));    

      Console.WriteLine("The original string:");
      Console.WriteLine(sb.ToString());
            
      // Decrease each number by one.
      for (int ctr = 0; ctr < sb.Length; ctr++) {
         if (Char.GetUnicodeCategory(sb[ctr]) == UnicodeCategory.DecimalDigitNumber) {
            int number = (int) Char.GetNumericValue(sb[ctr]);
            number--;
            if (number < 0) number = 9;
         
            sb[ctr] = number.ToString()[0];
         }
      }
      Console.WriteLine("\nThe new string:");
      Console.WriteLine(sb.ToString());
   }
}
// The example displays the following output:
//    The original string:
//    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
//    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
//    .00000
//    
//    The new string:
//    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
//    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
//    .99999
Imports System.Globalization
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      
      ' Generate 10 random numbers and store them in a StringBuilder.
      For ctr As Integer = 0 To 9
         sb.Append(rnd.Next().ToString("N5"))    
      Next
      Console.WriteLine("The original string:")
      Console.WriteLine(sb.ToString())
      Console.WriteLine()
            
      ' Decrease each number by one.
      For ctr As Integer = 0 To sb.Length - 1
         If Char.GetUnicodeCategory(sb(ctr)) = UnicodeCategory.DecimalDigitNumber Then
            Dim number As Integer = CType(Char.GetNumericValue(sb(ctr)), Integer)
            number -= 1
            If number < 0 Then number = 9
         
            sb(ctr) = number.ToString()(0)
         End If
      Next
      Console.WriteLine("The new string:")
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' The example displays the following output:
'    The original string:
'    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
'    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
'    .00000
'    
'    The new string:
'    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
'    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
'    .99999

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

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.

Nota

Incluso para un gran objeto StringBuilder pesado, el uso de la propiedad Chars[] para el acceso basado en índice a uno o un número reducido de caracteres tiene un efecto insignificante en el rendimiento; por lo general, es una operación 0(n). El impacto significativo en el rendimiento se produce al recorrer en iteración los caracteres del objeto StringBuilder, una operación O(n^2).

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.

Adición de texto a un objeto StringBuilder

La StringBuilder clase incluye los métodos siguientes para expandir el contenido de un StringBuilder objeto:

  • El Append método anexa una cadena, una subcadena, una matriz de caracteres, una parte de una matriz de caracteres, un único carácter repetido varias veces o la representación de cadena de un tipo de datos primitivo en un StringBuilder objeto .

  • El AppendLine método anexa un terminador de línea o una cadena junto con un terminador de línea a un StringBuilder objeto .

  • El AppendFormat método anexa una cadena de formato compuesto a un StringBuilder objeto . Las representaciones de cadena de los objetos incluidos en la cadena de resultado pueden reflejar las convenciones de formato de la referencia cultural del sistema actual o una referencia cultural especificada.

  • El Insert método inserta una cadena, una subcadena, varias repeticiones de una cadena, una matriz de caracteres, una parte de una matriz de caracteres o la representación de cadena de un tipo de datos primitivo en una posición especificada en el StringBuilder objeto. La posición se define mediante un índice de base cero.

En el ejemplo siguiente se usan los Appendmétodos , AppendLine, AppendFormaty Insert para expandir el texto de un StringBuilder objeto .

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      // Create a StringBuilder object with no text.
      StringBuilder sb = new StringBuilder();
      // Append some text.
      sb.Append('*', 10).Append(" Adding Text to a StringBuilder Object ").Append('*', 10);
      sb.AppendLine("\n");
      sb.AppendLine("Some code points and their corresponding characters:");
      // Append some formatted text.
      for (int ctr = 50; ctr <= 60; ctr++) {
         sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr));
         sb.AppendLine();
      }
      // Find the end of the introduction to the column.
      int pos = sb.ToString().IndexOf("characters:") + 11 + 
                Environment.NewLine.Length;
      // Insert a column header.
      sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit", 
                                   "Character", "\n"));      

      // Convert the StringBuilder to a string and display it.      
      Console.WriteLine(sb.ToString());      
   }
}
// The example displays the following output:
//    ********** Adding Text to a StringBuilder Object **********
//    
//    Some code points and their corresponding characters:
//    
//       Code Unit    Character
//            0032            2
//            0033            3
//            0034            4
//            0035            5
//            0036            6
//            0037            7
//            0038            8
//            0039            9
//            003A            :
//            003B            ;
//            003C            <
Imports System.Text

Module Example
   Public Sub Main()
      ' Create a StringBuilder object with no text.
      Dim sb As New StringBuilder()
      ' Append some text.
      sb.Append("*"c, 10).Append(" Adding Text to a StringBuilder Object ").Append("*"c, 10)
      sb.AppendLine()
      sb.AppendLine()
      sb.AppendLine("Some code points and their corresponding characters:")
      ' Append some formatted text.
      For ctr = 50 To 60
         sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr))
         sb.AppendLine()
      Next
      ' Find the end of the introduction to the column.
      Dim pos As Integer = sb.ToString().IndexOf("characters:") + 11 + 
                           Environment.NewLine.Length
      ' Insert a column header.
      sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit", 
                                   "Character", vbCrLf))      

      ' Convert the StringBuilder to a string and display it.      
      Console.WriteLine(sb.ToString())      
   End Sub
End Module
' The example displays the following output:
'       ********** Adding Text to a StringBuilder Object **********
'       
'       Some code points and their corresponding characters:
'       
'          Code Unit    Character
'               0032            2
'               0033            3
'               0034            4
'               0035            5
'               0036            6
'               0037            7
'               0038            8
'               0039            9
'               003A            :
'               003B            ;
'               003C            <

Eliminación de texto de un objeto StringBuilder

La StringBuilder clase incluye métodos que pueden reducir el tamaño de la instancia actual StringBuilder . El Clear método quita todos los caracteres y establece la Length propiedad en cero. El Remove método elimina un número especificado de caracteres a partir de una posición de índice determinada. Además, puede quitar caracteres del final de un StringBuilder objeto estableciendo su Length propiedad en un valor menor que la longitud de la instancia actual.

En el ejemplo siguiente se quita parte del texto de un StringBuilder objeto , se muestran sus valores de propiedad de capacidad, capacidad máxima y longitud resultantes y, a continuación, se llama al Clear método para quitar todos los caracteres del StringBuilder objeto .

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder("A StringBuilder object");
      ShowSBInfo(sb);
      // Remove "object" from the text.
      string textToRemove = "object";
      int pos = sb.ToString().IndexOf(textToRemove);
      if (pos >= 0) {
         sb.Remove(pos, textToRemove.Length);
         ShowSBInfo(sb);
      }
      // Clear the StringBuilder contents.
      sb.Clear();
      ShowSBInfo(sb);   
   }

   public static void ShowSBInfo(StringBuilder sb)
   {
      Console.WriteLine("\nValue: {0}", sb.ToString());
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Value: A StringBuilder object
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
//    
//    Value: A StringBuilder
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
//    
//    Value:
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0
Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder("A StringBuilder object")
      ShowSBInfo(sb)
      ' Remove "object" from the text.
      Dim textToRemove As String = "object"
      Dim pos As Integer = sb.ToString().IndexOf(textToRemove)
      If pos >= 0
         sb.Remove(pos, textToRemove.Length)
         ShowSBInfo(sb)
      End If
      ' Clear the StringBuilder contents.
      sb.Clear()
      ShowSBInfo(sb)   
   End Sub

   Public Sub ShowSBInfo(sb As StringBuilder)
      Console.WriteLine()
      Console.WriteLine("Value: {0}", sb.ToString())
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Value: A StringBuilder object
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
'    
'    Value: A StringBuilder
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
'    
'    Value:
'    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0

Modificación del texto en un objeto StringBuilder

El StringBuilder.Replace método reemplaza todas las apariciones de un carácter o una cadena en todo StringBuilder el objeto o en un intervalo de caracteres determinado. En el ejemplo siguiente se usa el Replace método para reemplazar todos los signos de exclamación (!) por signos de interrogación (?) en el StringBuilder objeto .

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
      MyStringBuilder.Replace('!', '?');
      Console.WriteLine(MyStringBuilder);
   }
}
// The example displays the following output:
//       Hello World?
Imports System.Text

Module Example
   Public Sub Main()
      Dim MyStringBuilder As New StringBuilder("Hello World!")
      MyStringBuilder.Replace("!"c, "?"c)
      Console.WriteLine(MyStringBuilder)
   End Sub
End Module
' The example displays the following output:
'       Hello World?

Búsqueda del texto en un objeto StringBuilder

La StringBuilder clase no incluye métodos similares a los String.Containsmétodos , String.IndexOfy String.StartsWith proporcionados por la String clase , que permiten buscar en el objeto un carácter determinado o una subcadena. La determinación de la posición de carácter inicial o presencia de una subcadena requiere que se busque un String valor mediante un método de búsqueda de cadenas o un método de expresión regular. Hay cuatro maneras de implementar estas búsquedas, como se muestra en la tabla siguiente.

Técnica Ventajas Desventajas
Buscar valores de cadena antes de agregarlos al StringBuilder objeto . Resulta útil para determinar si existe una subcadena. No se puede usar cuando la posición de índice de una subcadena es importante.
Llame ToString a y busque el objeto devuelto String . Fácil de usar si asigna todo el texto a un StringBuilder objeto y, a continuación, comienza a modificarlo. Engorroso llamar ToString repetidamente si debe realizar modificaciones antes de agregar todo el texto al StringBuilder objeto.

Debe recordar trabajar desde el final del StringBuilder texto del objeto si va a realizar cambios.
Utilice la Chars[] propiedad para buscar secuencialmente un intervalo de caracteres. Resulta útil si le preocupan los caracteres individuales o una subcadena pequeña. Engorroso si el número de caracteres que se va a buscar es grande o si la lógica de búsqueda es compleja.

Da como resultado un rendimiento muy deficiente para los objetos que han crecido muy grande a través de llamadas de método repetidas.
Convierta el StringBuilder objeto en un String objeto y realice modificaciones en el String objeto . Resulta útil si el número de modificaciones es pequeño. Niega la ventaja de rendimiento de la StringBuilder clase si el número de modificaciones es grande.

Vamos a examinar estas técnicas con mayor detalle.

  • Si el objetivo de la búsqueda es determinar si existe una subcadena determinada (es decir, si no está interesado en la posición de la subcadena), puede buscar cadenas antes de almacenarlas en el StringBuilder objeto. En el ejemplo siguiente se proporciona una posible implementación. Define una StringBuilderFinder clase cuyo constructor se pasa una referencia a un StringBuilder objeto y la subcadena que se va a buscar en la cadena. En este caso, el ejemplo intenta determinar si las temperaturas grabadas están en Fahrenheit o Celsius, y agrega el texto introductorio adecuado al principio del StringBuilder objeto. Se usa un generador de números aleatorios para seleccionar una matriz que contiene datos en grados Celsius o grados Fahrenheit.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          Random rnd = new Random();
          string[] tempF = { "47.6F", "51.3F", "49.5F", "62.3F" };
          string[] tempC = { "21.2C", "16.1C", "23.5C", "22.9C" };
          string[][] temps = { tempF, tempC }; 
    
          StringBuilder sb = new StringBuilder();
          var f = new StringBuilderFinder(sb, "F");
          var baseDate = new DateTime(2013, 5, 1); 
          String[] temperatures = temps[rnd.Next(2)];
          bool isFahrenheit = false;
          foreach (var temperature in temperatures) {
             if (isFahrenheit)
                sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature);
             else
                isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}\n", 
                                                 baseDate, temperature));
             baseDate = baseDate.AddDays(1);
          }            
          if (isFahrenheit) {
             sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit");
             sb.Insert(47, "\n\n");
          }
          else {
             sb.Insert(0, "Average Daily Temperature in Degrees Celsius");
             sb.Insert(44, "\n\n");
          }   
          Console.WriteLine(sb.ToString());
       }
    }
    
    public class StringBuilderFinder
    {
       private StringBuilder sb;
       private String text;
       
       public StringBuilderFinder(StringBuilder sb, String textToFind)
       {
          this.sb = sb;
          this.text = textToFind;
       }
       
       public bool SearchAndAppend(String stringToSearch)
       {
          sb.Append(stringToSearch);
          return stringToSearch.Contains(text);
       }
    }
    // The example displays output similar to the following:
    //    Average Daily Temperature in Degrees Celsius
    //    
    //    5/1/2013: 21.2C
    //    5/2/2013: 16.1C
    //    5/3/2013: 23.5C
    //    5/4/2013: 22.9C
    
    Imports System.Text
    
    Module Example
       Public Sub Main()
          Dim rnd As New Random()
          Dim tempF() As String = { "47.6F", "51.3F", "49.5F", "62.3F" }
          Dim tempC() As String = { "21.2C", "16.1C", "23.5C", "22.9C" }
          Dim temps()() As String = { tempF, tempC } 
    
          Dim sb As StringBuilder = New StringBuilder()
          Dim f As New StringBuilderFinder(sb, "F")
          Dim baseDate As New DateTime(2013, 5, 1) 
          Dim temperatures() As String = temps(rnd.Next(2))
          Dim isFahrenheit As Boolean = False
          For Each temperature In temperatures
             If isFahrenheit Then
                sb.AppendFormat("{0:d}: {1}{2}", baseDate, temperature, vbCrLf)
             Else
                isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}{2}", 
                                                 baseDate, temperature, vbCrLf))
             End If
             baseDate = baseDate.AddDays(1)
          Next            
          If isFahrenheit Then
             sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit")
             sb.Insert(47, vbCrLf + vbCrLf)
          Else
             sb.Insert(0, "Average Daily Temperature in Degrees Celsius")
             sb.Insert(44, vbCrLf + vbCrLf)
          End If   
          Console.WriteLine(sb.ToString())
       End Sub
    End Module
    
    Public Class StringBuilderFinder
       Private sb As StringBuilder
       Private text As String
       
       Public Sub New(sb As StringBuilder, textToFind As String)
          Me.sb = sb
          text = textToFind
       End Sub
       
       Public Function SearchAndAppend(stringToSearch As String) As Boolean
          sb.Append(stringToSearch)
          Return stringToSearch.Contains(text)
       End Function
    End Class
    ' The example displays output similar to the following:
    '    Average Daily Temperature in Degrees Celsius
    '    
    '    5/1/2013: 21.2C
    '    5/2/2013: 16.1C
    '    5/3/2013: 23.5C
    '    5/4/2013: 22.9C
    
  • Llame al StringBuilder.ToString método para convertir el StringBuilder objeto en un String objeto . Puede buscar la cadena mediante métodos como String.LastIndexOf o String.StartsWith, o puede usar expresiones regulares y la Regex clase para buscar patrones. Dado que tanto como StringBuilder String los objetos usan codificación UTF-16 para almacenar caracteres, las posiciones de índice de caracteres, subcadenas y coincidencias de expresiones regulares son las mismas en ambos objetos. Esto le permite usar StringBuilder métodos para realizar cambios en la misma posición en la que se encuentra el texto en el String objeto .

    Nota

    Si adopta este enfoque, debe trabajar desde el final del StringBuilder objeto hasta su principio para que no tenga que convertir repetidamente el StringBuilder objeto en una cadena.

    En el ejemplo siguiente se muestra este enfoque. Almacena cuatro apariciones de cada letra del alfabeto inglés en un StringBuilder objeto . A continuación, convierte el texto en un String objeto y usa una expresión regular para identificar la posición inicial de cada secuencia de cuatro caracteres. Por último, agrega un carácter de subrayado antes de cada secuencia de cuatro caracteres, excepto la primera secuencia, y convierte el primer carácter de la secuencia en mayúsculas.

    using System;
    using System.Text;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
          
          // Create a parallel string object.
          String sbString = sb.ToString();
          // Determine where each new character sequence begins.
          String pattern = @"(\w)\1+";
          MatchCollection matches = Regex.Matches(sbString, pattern);
    
          // Uppercase the first occurrence of the sequence, and separate it
          // from the previous sequence by an underscore character.
          for (int ctr = matches.Count - 1; ctr >= 0; ctr--) { 
             Match m = matches[ctr];
             sb[m.Index] = Char.ToUpper(sb[m.Index]);
             if (m.Index > 0) sb.Insert(m.Index, "_");
          }
          // Display the resulting string.
          sbString = sb.ToString();
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
    Imports System.Text
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To Ascw("z")
             sb.Append(ChrW(ctr), 4)
          Next    
          ' Create a parallel string object.
          Dim sbString As String = sb.ToString()
          ' Determine where each new character sequence begins.
          Dim pattern As String = "(\w)\1+"
          Dim matches As MatchCollection = Regex.Matches(sbString, pattern)
    
          ' Uppercase the first occurrence of the sequence, and separate it
          ' from the previous sequence by an underscore character.
          For ctr As Integer = matches.Count - 1 To 0 Step -1 
             Dim m As Match = matches(ctr)
             sb.Chars(m.Index) = Char.ToUpper(sb.Chars(m.index))
             If m.Index > 0 Then sb.Insert(m.Index, "_")
          Next
          ' Display the resulting string.
          sbString = sb.ToString()
          Dim line As Integer = 0
          Do
             Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                        80, sbString.Length - line * 80)
             Console.WriteLine(sbString.Substring(line * 80, nChars))
             line += 1
          Loop While line * 80 < sbString.Length
       End Sub
    End Module
    ' The example displays the following output:
    '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
  • Utilice la StringBuilder.Chars[] propiedad para buscar secuencialmente un intervalo de caracteres en un StringBuilder objeto . Este enfoque puede no ser práctico si el número de caracteres que se van a buscar es grande o la lógica de búsqueda es especialmente compleja. Para conocer las implicaciones de rendimiento del acceso basado en índices de caracteres por carácter para objetos muy grandes y fragmentados StringBuilder , consulte la documentación de la StringBuilder.Chars[] propiedad .

    El ejemplo siguiente es idéntico en la funcionalidad del ejemplo anterior, pero difiere en la implementación. Usa la Chars[] propiedad para detectar cuándo ha cambiado un valor de carácter, inserta un carácter de subrayado en esa posición y convierte el primer carácter de la nueva secuencia en mayúsculas.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort) 'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
    
          // Iterate the text to determine when a new character sequence occurs.
          int position = 0;
          Char current = '\u0000';
          do {
             if (sb[position] != current) {
                current = sb[position];
                sb[position] = Char.ToUpper(sb[position]);
                if (position > 0) 
                   sb.Insert(position, "_");
                position += 2;
             }
             else {
                position++;
             }      
          } while (position <= sb.Length - 1);
          // Display the resulting string.
          String sbString = sb.ToString();
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
    Imports System.Text
    
    Module Example
       Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To Ascw("z")
             sb.Append(ChrW(ctr), 4)
          Next    
          ' Iterate the text to determine when a new character sequence occurs.
          Dim position As Integer = 0
          Dim current As Char = ChrW(0)
          Do
             If sb(position) <> current Then
                current = sb(position)
                sb(position) = Char.ToUpper(sb(position))
                If position > 0 Then sb.Insert(position, "_")
                position += 2
             Else
                position += 1
             End If      
          Loop While position <= sb.Length - 1
          ' Display the resulting string.
          Dim sbString As String = sb.ToString()
          Dim line As Integer = 0
          Do
             Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                        80, sbString.Length - line * 80)
             Console.WriteLine(sbString.Substring(line * 80, nChars))
             line += 1
          Loop While line * 80 < sbString.Length
       End Sub
    End Module
    ' The example displays the following output:
    '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
  • Almacene todo el texto sin modificar en el StringBuilder objeto , llame al StringBuilder.ToString método para convertir el StringBuilder objeto en un String objeto y realice las modificaciones en el String objeto . Puede usar este enfoque si solo tiene algunas modificaciones; De lo contrario, el costo de trabajar con cadenas inmutables puede negar las ventajas de rendimiento de usar un StringBuilder objeto .

    El ejemplo siguiente es idéntico en funcionalidad a los dos ejemplos anteriores, pero difiere en la implementación. Crea un StringBuilder objeto, lo convierte en un String objeto y, a continuación, usa una expresión regular para realizar todas las modificaciones restantes en la cadena. El Regex.Replace(String, String, MatchEvaluator) método usa una expresión lambda para realizar el reemplazo en cada coincidencia.

    using System;
    using System.Text;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
         
          // Convert it to a string.
          String sbString = sb.ToString();
    
          // Use a regex to uppercase the first occurrence of the sequence, 
          // and separate it from the previous sequence by an underscore.
          string pattern = @"(\w)(\1+)";
          sbString = Regex.Replace(sbString, pattern, 
                                   m => (m.Index > 0 ? "_" : "") + 
                                   m.Groups[1].Value.ToUpper() + 
                                   m.Groups[2].Value);
    
          // Display the resulting string.
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
    Imports System.Text
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          ' Create a StringBuilder object with 4 successive occurrences 
          ' of each character in the English alphabet. 
          Dim sb As New StringBuilder()
          For ctr As UShort = AscW("a") To Ascw("z")
             sb.Append(ChrW(ctr), 4)
          Next    
          ' Convert it to a string.
          Dim sbString As String = sb.ToString()
    
          ' Use a regex to uppercase the first occurrence of the sequence, 
          ' and separate it from the previous sequence by an underscore.
          Dim pattern As String = "(\w)(\1+)"
          sbString = Regex.Replace(sbString, pattern, 
                                   Function(m) If(m.Index > 0,"_","") + 
                                               m.Groups(1).Value.ToUpper + 
                                               m.Groups(2).Value)
    
          ' Display the resulting string.
          Dim line As Integer = 0
          Do
             Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                        80, sbString.Length - line * 80)
             Console.WriteLine(sbString.Substring(line * 80, nChars))
             line += 1
          Loop While line * 80 < sbString.Length
       End Sub
    End Module
    ' The example displays the following output:
    '    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    '    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    

Convertir el objeto StringBuilder en una cadena

Debe convertir primero el objeto StringBuilder en un objeto String para poder pasar la cadena representada por el objeto StringBuilder a un método con un parámetro String o mostrarla en la interfaz de usuario. Para realizar esta conversión, llame al StringBuilder.ToString método . Para obtener una ilustración, vea el ejemplo anterior, que llama al ToString método para convertir un StringBuilder objeto en una cadena para que se pueda pasar a un método de expresión regular.

Notas a los autores de las llamadas

En .NET Core y en .NET Framework 4.0 y versiones posteriores, al crear una instancia del StringBuilder objeto llamando al StringBuilder(Int32, Int32) constructor, tanto la longitud como la capacidad de la StringBuilder instancia pueden crecer más allá del valor de su MaxCapacity propiedad. Esto puede ocurrir especialmente cuando se llama a los Append(String) métodos y AppendFormat(String, Object) para anexar cadenas pequeñas.

Constructores

StringBuilder()

Inicializa una nueva instancia de la clase StringBuilder.

StringBuilder(Int32)

Inicializa una nueva instancia de la clase StringBuilder con la capacidad especificada.

StringBuilder(Int32, Int32)

Inicializa una nueva instancia de la clase StringBuilder que empieza con una capacidad concreta y puede aumentar hasta un máximo especificado.

StringBuilder(String)

Inicializa una nueva instancia de la clase StringBuilder con la cadena especificada.

StringBuilder(String, Int32)

Inicializa una nueva instancia de la clase StringBuilder con la capacidad y la cadena especificadas.

StringBuilder(String, Int32, Int32, Int32)

Inicializa una nueva instancia de la clase StringBuilder a partir de la subcadena y la capacidad especificadas.

Propiedades

Capacity

Obtiene o establece el número máximo de caracteres que puede contener la memoria asignada por la instancia en uso.

Chars[Int32]

Obtiene o establece el carácter en la posición de carácter especificada en la instancia.

Length

Obtiene o establece la longitud del objeto StringBuilder actual.

MaxCapacity

Obtiene la capacidad máxima de la instancia.

Métodos

Append(Boolean)

Anexa a esta instancia la representación en forma de cadena de un valor booleano especificado.

Append(Byte)

Anexa a esta instancia la representación en forma de cadena de un entero sin signo de 8 bits especificado.

Append(Char)

Anexa a esta instancia la representación en forma de cadena de un objeto Char especificado.

Append(Char*, Int32)

Anexa a esta instancia una matriz de caracteres Unicode a partir de una dirección especificada.

Append(Char, Int32)

Anexa a esta instancia un número especificado de copias de la representación en forma de cadena de un carácter Unicode.

Append(Char[])

Anexa a esta instancia la representación en forma de cadena de los caracteres Unicode de una matriz especificada.

Append(Char[], Int32, Int32)

Anexa a esta instancia la representación en forma de cadena de una submatriz de caracteres Unicode especificada.

Append(Decimal)

Anexa a esta instancia la representación en forma de cadena de un número decimal especificado.

Append(Double)

Anexa a esta instancia la representación en forma de cadena de un número de punto flotante de precisión doble especificado.

Append(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

Anexa la cadena interpolada especificada a esta instancia con el formato especificado.

Append(Int16)

Anexa a esta instancia la representación en forma de cadena de un entero con signo de 16 bits especificado.

Append(Int32)

Anexa a esta instancia la representación en forma de cadena de un entero con signo de 32 bits especificado.

Append(Int64)

Anexa a esta instancia la representación en forma de cadena de un entero con signo de 64 bits especificado.

Append(Object)

Anexa a esta instancia la representación en forma de cadena de un objeto especificado.

Append(ReadOnlyMemory<Char>)

Anexa a esta instancia la representación en forma de cadena de una región de memoria de carácter de solo lectura especificado.

Append(ReadOnlySpan<Char>)

Anexa a esta instancia la representación en forma de cadena de un intervalo de caracteres de solo lectura especificado.

Append(SByte)

Anexa a esta instancia la representación en forma de cadena de un entero con signo de 8 bits especificado.

Append(Single)

Anexa a esta instancia la representación en forma de cadena de un número de punto flotante de precisión sencilla especificado.

Append(String)

Anexa a esta instancia una copia de la cadena especificada.

Append(String, Int32, Int32)

Anexa a esta instancia una copia de una subcadena especificada.

Append(StringBuilder)

Anexa a esta instancia la representación en forma de cadena de un generador de cadena especificado.

Append(StringBuilder, Int32, Int32)

Anexa a esta instancia una copia de una subcadena dentro de un generador de cadena especificado.

Append(StringBuilder+AppendInterpolatedStringHandler)

Anexa la cadena interpolada especificada a esta instancia.

Append(UInt16)

Anexa a esta instancia la representación en forma de cadena de un entero sin signo de 16 bits especificado.

Append(UInt32)

Anexa a esta instancia la representación en forma de cadena de un entero sin signo de 32 bits especificado.

Append(UInt64)

Anexa a esta instancia la representación en forma de cadena de un entero sin signo de 64 bits especificado.

AppendFormat(IFormatProvider, String, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación en forma de cadena de un único argumento utilizando un proveedor de formato especificado.

AppendFormat(IFormatProvider, String, Object, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación de cadena de dos argumentos utilizando un proveedor de formato especificado.

AppendFormat(IFormatProvider, String, Object, Object, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación de cadena de tres argumentos utilizando un proveedor de formato especificado.

AppendFormat(IFormatProvider, String, Object[])

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza con la representación de cadena del argumento correspondiente de una matriz de parámetros, utilizando el proveedor de formato especificado.

AppendFormat(String, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación en forma de cadena de un único argumento.

AppendFormat(String, Object, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación en forma de cadena de uno de dos argumentos.

AppendFormat(String, Object, Object, Object)

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación en forma de cadena de uno de tres argumentos.

AppendFormat(String, Object[])

Anexa a esta instancia la cadena que se devuelve al procesar una cadena con formato compuesto, que contiene cero o más elementos de formato. Cada elemento de formato se reemplaza por la representación de cadena del argumento correspondiente de una matriz de parámetros.

AppendJoin(Char, Object[])

Concatena las representaciones de cadena de los elementos de la matriz de objetos proporcionada, con el separador de caracteres especificado entre cada miembro y, después, anexa el resultado a la instancia actual del generador de cadenas.

AppendJoin(Char, String[])

Concatena las cadenas de la matriz proporcionada, con el separador de caracteres especificado entre cada cadena y, después, anexa el resultado a la instancia actual del generador de cadenas.

AppendJoin(String, Object[])

Concatena las representaciones de cadena de los elementos de la matriz de objetos proporcionada, con el separador especificado entre cada miembro y, después, anexa el resultado a la instancia actual del generador de cadenas.

AppendJoin(String, String[])

Concatena las cadenas de la matriz proporcionada, con el separador especificado entre cada cadena y, después, anexa el resultado a la instancia actual del generador de cadenas.

AppendJoin<T>(Char, IEnumerable<T>)

Concatena y anexa los miembros de una colección, con el separador de caracteres especificado entre todos los miembros.

AppendJoin<T>(String, IEnumerable<T>)

Concatena y anexa los miembros de una colección, con el separador especificado entre todos los miembros.

AppendLine()

Anexa el terminador de línea predeterminado al final del objeto StringBuilder actual.

AppendLine(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

Anexa la cadena interpolada especificada con el formato especificado, seguido del terminador de línea predeterminado, al final del objeto StringBuilder actual.

AppendLine(String)

Anexa una copia de la cadena especificada seguida del terminador de línea predeterminado al final del objeto StringBuilder actual.

AppendLine(StringBuilder+AppendInterpolatedStringHandler)

Anexa la cadena interpolada especificada seguida del terminador de línea predeterminado al final del objeto StringBuilder actual.

Clear()

Quita todos los caracteres de la instancia de StringBuilder actual.

CopyTo(Int32, Char[], Int32, Int32)

Copia los caracteres de un segmento especificado de esta instancia al segmento especificado de una matriz Char de destino.

CopyTo(Int32, Span<Char>, Int32)

Copia los caracteres de un segmento especificado de esta instancia en un intervalo Char de destino.

EnsureCapacity(Int32)

Garantiza que la capacidad de la instancia de StringBuilder corresponde como mínimo al valor especificado.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
Equals(ReadOnlySpan<Char>)

Devuelve un valor que indica si los caracteres de esta instancia son iguales a los caracteres de un intervalo de caracteres especificado de solo lectura.

Equals(StringBuilder)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.

GetChunks()

Devuelve un objeto que se puede utilizar para recorrer en iteración los fragmentos de caracteres representados en un elemento ReadOnlyMemory<Char> creado a partir de esta instancia StringBuilder.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
Insert(Int32, Boolean)

Inserta en la instancia la representación en forma de cadena de un valor booleano en la posición del carácter que se haya especificado.

Insert(Int32, Byte)

Inserta en la instancia la representación en forma de cadena de un entero de 8 bits sin signo, en la posición del carácter que se haya especificado.

Insert(Int32, Char)

Inserta en la instancia la representación en forma de cadena de un carácter Unicode concreto en la posición del carácter que se haya especificado.

Insert(Int32, Char[])

Inserta en la instancia la representación en forma de cadena de una matriz concreta de caracteres Unicode en la posición del carácter que se haya especificado.

Insert(Int32, Char[], Int32, Int32)

Inserta en la instancia la representación en forma de cadena de una submatriz concreta de caracteres Unicode en la posición del carácter que se haya especificado.

Insert(Int32, Decimal)

Inserta en la instancia la representación en forma de cadena de un número decimal en la posición del carácter que se haya especificado.

Insert(Int32, Double)

Inserta en la instancia la representación en forma de cadena de un número de punto flotante de doble precisión en la posición del carácter que se haya especificado.

Insert(Int32, Int16)

Inserta en la instancia la representación en forma de cadena de un entero de 16 bits con signo especificado, en la posición del carácter que se haya indicado.

Insert(Int32, Int32)

Inserta en la instancia la representación en forma de cadena de un entero de 32 bits con signo especificado, en la posición del carácter que se haya indicado.

Insert(Int32, Int64)

Inserta en la instancia la representación en forma de cadena de un entero de 64 bits con signo, en la posición del carácter que se haya especificado.

Insert(Int32, Object)

Inserta en la instancia la representación en forma de cadena de un objeto en la posición del carácter que se haya especificado.

Insert(Int32, ReadOnlySpan<Char>)

Inserta la secuencia de caracteres en esta instancia, en la posición de carácter especificada.

Insert(Int32, SByte)

Inserta en la instancia la representación en forma de cadena de un entero de 8 bits con signo especificado, en la posición del carácter que se haya indicado.

Insert(Int32, Single)

Inserta en la instancia la representación en forma de cadena de un número de punto flotante de precisión sencilla, en la posición del carácter que se haya especificado.

Insert(Int32, String)

Inserta una cadena en la instancia en la posición del carácter que se haya especificado.

Insert(Int32, String, Int32)

Inserta en la instancia una o más copias de una cadena concreta en la posición del carácter que se haya especificado.

Insert(Int32, UInt16)

Inserta en la instancia la representación en forma de cadena de un entero de 16 bits sin signo, en la posición del carácter que se haya especificado.

Insert(Int32, UInt32)

Inserta en la instancia la representación en forma de cadena de un entero de 32 bits sin signo, en la posición del carácter que se haya especificado.

Insert(Int32, UInt64)

Inserta en la instancia la representación en forma de cadena de un entero de 64 bits sin signo, en la posición del carácter que se haya especificado.

MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
Remove(Int32, Int32)

Quita de la instancia el intervalo de caracteres especificado.

Replace(Char, Char)

Reemplaza todas las apariciones de un carácter en la instancia por otro carácter especificado.

Replace(Char, Char, Int32, Int32)

En una subcadena de la instancia, reemplaza todas las apariciones de un carácter especificado por otro carácter especificado.

Replace(String, String)

Reemplaza todas las apariciones de una cadena especificada en la instancia por otra cadena especificada.

Replace(String, String, Int32, Int32)

En una subcadena de la instancia, reemplaza todas las apariciones de una cadena especificada por otra cadena especificada.

ToString()

Convierte el valor de la instancia en un objeto String.

ToString(Int32, Int32)

Convierte el valor de una subcadena de la instancia en un objeto String.

Implementaciones de interfaz explícitas

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena un objeto SerializationInfo con los datos necesarios para deserializar el objeto StringBuilder actual.

Se aplica a

Consulte también