StringBuilder StringBuilder StringBuilder StringBuilder Class

Definição

Representa uma cadeia de caracteres mutável.Represents a mutable string of characters. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class StringBuilder sealed : System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class StringBuilder : System.Runtime.Serialization.ISerializable
type StringBuilder = class
    interface ISerializable
Public NotInheritable Class StringBuilder
Implements ISerializable
Herança
StringBuilderStringBuilderStringBuilderStringBuilder
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como chamar muitos dos métodos definidos pela StringBuilder classe.The following example shows how to call many of the methods defined by the StringBuilder class.

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

Comentários

Essa classe representa um objeto de cadeia de caracteres cujo valor é uma sequência mutável de caracteres.This class represents a string-like object whose value is a mutable sequence of characters.

Nesta seção:In this section:

Os tipos String e StringBuilderThe String and StringBuilder types

Embora StringBuilder eString ambos representem sequências de caracteres, eles são implementados de forma diferente.Although StringBuilder and String both represent sequences of characters, they are implemented differently. Stringé um tipo imutável.String is an immutable type. Ou seja, cada operação que aparece para modificar um String objeto realmente cria uma nova cadeia de caracteres.That is, each operation that appears to modify a String object actually creates a new string.

Por exemplo, a chamada para o String.Concat método no exemplo a C# seguir parece alterar o valor de uma variável de cadeia de valuecaracteres chamada.For example, the call to the String.Concat method in the following C# example appears to change the value of a string variable named value. Na verdade, o Concat método retorna um value objeto que tem um value valor e um endereço diferentes do objeto que foi passado para o método.In fact, the Concat method returns a value object that has a different value and address from the value object that was passed to the method. Observe que o exemplo deve ser compilado usando a /unsafe opção do compilador.Note that the example must be compiled using the /unsafe compiler option.

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

Para rotinas que executam manipulação de cadeia de caracteres extensiva (como aplicativos que modificam uma cadeia de caracteres várias vezes em um loop), modificar uma cadeia de caracteres repetidamente pode ser exatamente uma penalidade de desempenho significativa.For routines that perform extensive string manipulation (such as apps that modify a string numerous times in a loop), modifying a string repeatedly can exact a significant performance penalty. A alternativa é usar StringBuilder, que é uma classe de cadeia de caracteres mutável.The alternative is to use StringBuilder, which is a mutable string class. A imutabilidade significa que, depois que uma instância da classe tiver sido criada, ela poderá ser modificada acrescentando, removendo, substituindo ou inserindo caracteres.Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. Um StringBuilder objeto mantém um buffer para acomodar expansões para a cadeia de caracteres.A StringBuilder object maintains a buffer to accommodate expansions to the string. Novos dados serão anexados ao buffer se a sala estiver disponível; caso contrário, um buffer novo e maior é alocado, os dados do buffer original são copiados para o novo buffer e os novos dados são então anexados ao novo buffer.New data is appended to the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, and the new data is then appended to the new buffer.

Importante

Embora a StringBuilder classe geralmente ofereça um desempenho melhor do String que a classe, você não deve String substituir StringBuilder automaticamente por sempre que quiser manipular cadeias de caracteres.Although the StringBuilder class generally offers better performance than the String class, you should not automatically replace String with StringBuilder whenever you want to manipulate strings. O desempenho depende do tamanho da cadeia de caracteres, da quantidade de memória a ser alocada para a nova cadeia de caracteres, do sistema no qual seu aplicativo está sendo executado e do tipo de operação.Performance depends on the size of the string, the amount of memory to be allocated for the new string, the system on which your app is executing, and the type of operation. Você deve estar preparado para testar seu aplicativo para determinar se StringBuilder realmente oferece uma melhoria significativa no desempenho.You should be prepared to test your app to determine whether StringBuilder actually offers a significant performance improvement.

Considere o uso String da classe sob estas condições:Consider using the String class under these conditions:

  • Quando o número de alterações que seu aplicativo fará em uma cadeia de caracteres for pequeno.When the number of changes that your app will make to a string is small. Nesses casos, StringBuilder o pode oferecer uma Stringmelhoria de desempenho insignificante ou não.In these cases, StringBuilder might offer negligible or no performance improvement over String.

  • Quando você estiver executando um número fixo de operações de concatenação, particularmente com literais de cadeia de caracteres.When you are performing a fixed number of concatenation operations, particularly with string literals. Nesse caso, o compilador pode combinar as operações de concatenação em uma única operação.In this case, the compiler might combine the concatenation operations into a single operation.

  • Quando você precisa executar operações de pesquisa extensivas enquanto estiver criando sua cadeia de caracteres.When you have to perform extensive search operations while you are building your string. A StringBuilder classe não tem métodos de pesquisa IndexOf como ou StartsWith.The StringBuilder class lacks search methods such as IndexOf or StartsWith. Você precisará converter o StringBuilder objeto em um String para essas operações, e isso pode negar o benefício de desempenho do uso StringBuilderdo.You'll have to convert the StringBuilder object to a String for these operations, and this can negate the performance benefit from using StringBuilder. Para obter mais informações, consulte a seção pesquisando o texto em um objeto StringBuilder .For more information, see the Searching the text in a StringBuilder object section.

Considere o uso StringBuilder da classe sob estas condições:Consider using the StringBuilder class under these conditions:

  • Quando você espera que seu aplicativo faça um número desconhecido de alterações em uma cadeia de caracteres em tempo de design (por exemplo, quando você está usando um loop para concatenar um número aleatório de cadeias de caracteres que contêm entrada do usuário).When you expect your app to make an unknown number of changes to a string at design time (for example, when you are using a loop to concatenate a random number of strings that contain user input).

  • Quando você espera que seu aplicativo faça um número significativo de alterações em uma cadeia de caracteres.When you expect your app to make a significant number of changes to a string.

Como StringBuilder funcionaHow StringBuilder works

A StringBuilder.Length propriedade indica o número de caracteres que StringBuilder o objeto contém no momento.The StringBuilder.Length property indicates the number of characters the StringBuilder object currently contains. Se você adicionar caracteres ao StringBuilder objeto, seu comprimento aumentará até que ele seja igual ao tamanho StringBuilder.Capacity da propriedade, que define o número de caracteres que o objeto pode conter.If you add characters to the StringBuilder object, its length increases until it equals the size of the StringBuilder.Capacity property, which defines the number of characters that the object can contain. Se o número de caracteres adicionados fizer com que o comprimento StringBuilder do objeto exceda sua capacidade atual, a nova memória será alocada, o Capacity valor da propriedade será duplicado, novos StringBuilder caracteres serão adicionados ao objeto e seu Lengtha propriedade é ajustada.If the number of added characters causes the length of the StringBuilder object to exceed its current capacity, new memory is allocated, the value of the Capacity property is doubled, new characters are added to the StringBuilder object, and its Length property is adjusted. Memória adicional para o StringBuilder objeto é alocada dinamicamente até atingir o valor definido StringBuilder.MaxCapacity pela propriedade.Additional memory for the StringBuilder object is allocated dynamically until it reaches the value defined by the StringBuilder.MaxCapacity property. Quando a capacidade máxima é atingida, nenhuma outra memória pode ser alocada StringBuilder para o objeto e tentar adicionar caracteres ou expandi-la além de sua capacidade máxima gera ArgumentOutOfRangeException uma ou OutOfMemoryException uma exceção.When the maximum capacity is reached, no further memory can be allocated for the StringBuilder object, and trying to add characters or expand it beyond its maximum capacity throws either an ArgumentOutOfRangeException or an OutOfMemoryException exception.

O exemplo a seguir ilustra como StringBuilder um objeto aloca uma nova memória e aumenta sua capacidade dinamicamente à medida que a cadeia de caracteres atribuída ao objeto é expandida.The following example illustrates how a StringBuilder object allocates new memory and increases its capacity dynamically as the string assigned to the object expands. O código cria um StringBuilder objeto chamando seu construtor padrão (sem parâmetros).The code creates a StringBuilder object by calling its default (parameterless) constructor. A capacidade padrão desse objeto é de 16 caracteres e sua capacidade máxima é maior que 2.000.000.000 caracteres.The default capacity of this object is 16 characters, and its maximum capacity is more than 2 billion characters. Acrescentando a cadeia de caracteres "esta é uma frase".Appending the string "This is a sentence." resulta em uma nova alocação de memória porque o comprimento da cadeia de caracteres (19 caracteres) excede a StringBuilder capacidade padrão do objeto.results in a new memory allocation because the string length (19 characters) exceeds the default capacity of the StringBuilder object. A capacidade do objeto dobra para 32 caracteres, a nova cadeia de caracteres é adicionada e o comprimento do objeto agora é igual a 19 caracteres.The capacity of the object doubles to 32 characters, the new string is added, and the length of the object now equals 19 characters. Em seguida, o código acrescenta a cadeia de caracteres "esta é uma frase adicional".The code then appends the string "This is an additional sentence." para o valor do StringBuilder objeto 11 vezes.to the value of the StringBuilder object 11 times. Sempre que a operação de acréscimo faz com que StringBuilder o comprimento do objeto exceda sua capacidade, sua capacidade existente é duplicada e a Append operação é realizada com sucesso.Whenever the append operation causes the length of the StringBuilder object to exceed its capacity, its existing capacity is doubled and the Append operation succeeds.

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

Alocação de memóriaMemory allocation

A capacidade padrão de um StringBuilder objeto é de 16 caracteres e sua capacidade máxima padrão é Int32.MaxValue.The default capacity of a StringBuilder object is 16 characters, and its default maximum capacity is Int32.MaxValue. Esses valores padrão serão usados se você chamar os StringBuilder() construtores StringBuilder(String) e.These default values are used if you call the StringBuilder() and StringBuilder(String) constructors.

Você pode definir explicitamente a capacidade inicial de um StringBuilder objeto das seguintes maneiras:You can explicitly define the initial capacity of a StringBuilder object in the following ways:

  • Chamando qualquer um dos StringBuilder construtores que inclui um capacity parâmetro quando você cria o objeto.By calling any of the StringBuilder constructors that includes a capacity parameter when you create the object.

  • Atribuindo explicitamente um novo valor à StringBuilder.Capacity propriedade para expandir um objeto existente. StringBuilderBy explicitly assigning a new value to the StringBuilder.Capacity property to expand an existing StringBuilder object. Observe que a propriedade gera uma exceção se a nova capacidade for menor que a capacidade existente ou maior que a StringBuilder capacidade máxima do objeto.Note that the property throws an exception if the new capacity is less than the existing capacity or greater than the StringBuilder object's maximum capacity.

  • Chamando o StringBuilder.EnsureCapacity método com a nova capacidade.By calling the StringBuilder.EnsureCapacity method with the new capacity. A nova capacidade não deve ser maior que a StringBuilder capacidade máxima do objeto.The new capacity must not be greater than the StringBuilder object's maximum capacity. No entanto, ao contrário de Capacity uma atribuição EnsureCapacity para a propriedade, o não lançará uma exceção se a nova capacidade desejada for menor que a capacidade existente; nesse caso, a chamada de método não terá nenhum efeito.However, unlike an assignment to the Capacity property, EnsureCapacity does not throw an exception if the desired new capacity is less than the existing capacity; in this case, the method call has no effect.

Se o comprimento da cadeia de caracteres atribuída ao StringBuilder objeto na chamada do Construtor exceder a capacidade padrão ou a capacidade especificada, a Capacity propriedade será definida como o comprimento da cadeia de caracteres especificada com value o parâmetro.If the length of the string assigned to the StringBuilder object in the constructor call exceeds either the default capacity or the specified capacity, the Capacity property is set to the length of the string specified with the value parameter.

Você pode definir explicitamente a capacidade máxima de um StringBuilder objeto chamando o StringBuilder(Int32, Int32) Construtor.You can explicitly define the maximum capacity of a StringBuilder object by calling the StringBuilder(Int32, Int32) constructor. Não é possível alterar a capacidade máxima atribuindo um novo valor à MaxCapacity Propriedade, pois ela é somente leitura.You can't change the maximum capacity by assigning a new value to the MaxCapacity property, because it is read-only.

Como mostra a seção anterior, sempre que a capacidade existente é inadequada, a memória adicional é alocada e a StringBuilder capacidade de um objeto dobra para o valor definido MaxCapacity pela propriedade.As the previous section shows, whenever the existing capacity is inadequate, additional memory is allocated and the capacity of a StringBuilder object doubles up to the value defined by the MaxCapacity property.

Em geral, a capacidade padrão e a capacidade máxima são adequadas para a maioria dos aplicativos.In general, the default capacity and maximum capacity are adequate for most apps. Você pode considerar definir esses valores nas seguintes condições:You might consider setting these values under the following conditions:

  • Se o tamanho eventual do StringBuilder objeto provavelmente crescer muito grande, normalmente excedendo vários megabytes.If the eventual size of the StringBuilder object is likely to grow exceedingly large, typically in excess of several megabytes. Nesse caso, pode haver algum benefício de desempenho na definição da propriedade inicial Capacity com um valor significativamente alto para eliminar a necessidade de muitas realocações de memória.In this case, there may be some performance benefit from setting the initial Capacity property to a significantly high value to eliminate the need for too many memory reallocations.

  • Se seu aplicativo estiver em execução em um sistema com memória limitada.If your app is running on a system with limited memory. Nesse caso, talvez você queira considerar a definição da MaxCapacity Propriedade como menor que Int32.MaxValue se seu aplicativo estiver manipulando cadeias de caracteres grandes que podem fazer com que ele seja executado em um ambiente com restrição de memória.In this case, you may want to consider setting the MaxCapacity property to less than Int32.MaxValue if your app is handling large strings that may cause it to execute in a memory-constrained environment.

Criando uma instância de um objeto StringBuilderInstantiating a StringBuilder object

Você cria uma StringBuilder instância de um objeto chamando um dos seis construtores de classe sobrecarregados, que são listados na tabela a seguir.You instantiate a StringBuilder object by calling one of its six overloaded class constructors, which are listed in the following table. Três dos construtores instanciam um StringBuilder objeto cujo valor é uma cadeia de caracteres vazia, mas definem seus Capacity valores e MaxCapacity de forma diferente.Three of the constructors instantiate a StringBuilder object whose value is an empty string, but set its Capacity and MaxCapacity values differently. Os três construtores restantes definem um StringBuilder objeto que tem um valor e uma capacidade de cadeia de caracteres específicos.The remaining three constructors define a StringBuilder object that has a specific string value and capacity. Dois dos três construtores usam a capacidade máxima padrão de Int32.MaxValue, enquanto o terceiro permite que você defina a capacidade máxima.Two of the three constructors use the default maximum capacity of Int32.MaxValue, whereas the third allows you to set the maximum capacity.

ConstrutorConstructor Valor da cadeia de caracteresString value CapacidadeCapacity Capacidade máximaMaximum capacity
StringBuilder() String.Empty 1616 Int32.MaxValue
StringBuilder(Int32) String.Empty Definido pelo capacity parâmetroDefined by the capacity parameter Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Definido pelo capacity parâmetroDefined by the capacity parameter Definido pelo maxCapacity parâmetroDefined by the maxCapacity parameter
StringBuilder(String) Definido pelo value parâmetroDefined by the value parameter 16 ou value.16 or value. Length, o que for maiorLength, whichever is greater Int32.MaxValue
StringBuilder(String, Int32) Definido pelo value parâmetroDefined by the value parameter Definido pelo capacity parâmetro ou value.Defined by the capacity parameter or value. Length, o que for maior.Length, whichever is greater. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) Definido por value.Defined by value. Substring(startIndex, length)Substring(startIndex, length) Definido pelo capacity parâmetro ou value.Defined by the capacity parameter or value. Length, o que for maior.Length, whichever is greater. Definido pelo maxCapacity parâmetroDefined by the maxCapacity parameter

O exemplo a seguir usa três dessas sobrecargas de construtor para StringBuilder criar uma instância de objetos.The following example uses three of these constructor overloads to instantiate StringBuilder objects.

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

Chamando métodos StringBuilderCalling StringBuilder methods

A maioria dos métodos que modificam a cadeia de StringBuilder caracteres em uma instância retorna uma referência a essa mesma instância.Most of the methods that modify the string in a StringBuilder instance return a reference to that same instance. Isso permite que você chame StringBuilder métodos de duas maneiras:This enables you to call StringBuilder methods in two ways:

  • Você pode fazer chamadas de método individuais e ignorar o valor de retorno, como faz o exemplo a seguir.You can make individual method calls and ignore the return value, as the following example does.

    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.
    
  • Você pode fazer uma série de chamadas de método em uma única instrução.You can make a series of method calls in a single statement. Isso pode ser conveniente se você quiser escrever uma única instrução que encadeia operações sucessivas.This can be convenient if you want to write a single statement that chains successive operations. O exemplo a seguir consolida três chamadas de método do exemplo anterior em uma única linha de código.The following example consolidates three method calls from the previous example into a single line of code.

    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.
    

Executando operações StringBuilderPerforming StringBuilder operations

Você pode usar os métodos da StringBuilder classe para iterar, adicionar, excluir ou modificar caracteres em um StringBuilder objeto.You can use the methods of the StringBuilder class to iterate, add, delete, or modify characters in a StringBuilder object.

Iterando caracteres StringBuilderIterating StringBuilder characters

Você pode acessar os caracteres em um StringBuilder objeto usando a StringBuilder.Chars[Int32] propriedade.You can access the characters in a StringBuilder object by using the StringBuilder.Chars[Int32] property. No C#, Chars[Int32] é um indexador; em Visual Basic, é a propriedade StringBuilder padrão da classe.In C#, Chars[Int32] is an indexer; in Visual Basic, it is the default property of the StringBuilder class. Isso permite que você defina ou recupere caracteres individuais usando somente o índice, sem referenciar explicitamente a Chars[Int32] propriedade.This enables you to set or retrieve individual characters by using their index only, without explicitly referencing the Chars[Int32] property. Os caracteres em StringBuilder um objeto começam no índice 0 (zero) e continuam no Length índice-1.Characters in a StringBuilder object begin at index 0 (zero) and continue to index Length - 1.

O exemplo a seguir ilustra Chars[Int32] a propriedade.The following example illustrates the Chars[Int32] property. Ele acrescenta dez números aleatórios a um StringBuilder objeto e, em seguida, itera cada caractere.It appends ten random numbers to a StringBuilder object, and then iterates each character. Se a categoria Unicode do caractere for UnicodeCategory.DecimalDigitNumber, ela diminuirá o número em 1 (ou alterará o número para 9 se seu valor for 0).If the character's Unicode category is UnicodeCategory.DecimalDigitNumber, it decreases the number by 1 (or changes the number to 9 if its value is 0). O exemplo exibe o conteúdo do StringBuilder objeto antes e depois que os valores de caracteres individuais foram alterados.The example displays the contents of the StringBuilder object both before and after the values of individual characters were changed.

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

O uso da indexação baseada em caracteres com a propriedade Chars[Int32] pode ser extremamente lento nas seguintes condições:Using character-based indexing with the Chars[Int32] property can be extremely slow under the following conditions:

O desempenho é afetado gravemente porque cada acesso de caractere percorre toda a lista vinculada de partes para localizar o buffer correto ao qual indexar.Performance is severely impacted because each character access walks the entire linked list of chunks to find the correct buffer to index into.

Observação

Mesmo para um grande objeto StringBuilder “robusto", usar a propriedade Chars[Int32] para o acesso baseado em índice a um ou um pequeno número de caracteres tem impacto insignificante sobre o desempenho. Normalmente, trata-se de uma operação 0(n) .Even for a large "chunky" StringBuilder object, using the Chars[Int32] property for index-based access to one or a small number of characters has a negligible performance impact; typically, it is an 0(n) operation. O impacto significativo sobre o desempenho ocorre ao iterar os caracteres no objeto StringBuilder, que é uma operação O(n^2) .The significant performance impact occurs when iterating the characters in the StringBuilder object, which is an O(n^2) operation.

Se encontrar problemas de desempenho ao usar a indexação baseada em caractere com objetos StringBuilder, você poderá usar qualquer uma das seguintes alternativas:If you encounter performance issues when using character-based indexing with StringBuilder objects, you can use any of the following workarounds:

  • Converter a instância StringBuilder para um String chamando o método ToString e, em seguida, acessar os caracteres na cadeia de caracteres.Convert the StringBuilder instance to a String by calling the ToString method, then access the characters in the string.

  • Copiar o conteúdo do objeto StringBuilder existente para um novo objeto StringBuilder pré-dimensionado.Copy the contents of the existing StringBuilder object to a new pre-sized StringBuilder object. O desempenho melhora porque o novo objeto StringBuilder não é robusto.Performance improves because the new StringBuilder object is not chunky. Por exemplo:For example:

    // 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).Set the initial capacity of the StringBuilder object to a value that is approximately equal to its maximum expected size by calling the StringBuilder(Int32) constructor. Observe que isso aloca o bloco de memória inteiro mesmo que o StringBuilder raramente atinja sua capacidade máxima.Note that this allocates the entire block of memory even if the StringBuilder rarely reaches its maximum capacity.

Adicionando texto a um objeto StringBuilderAdding text to a StringBuilder object

A StringBuilder classe inclui os seguintes métodos para expandir o conteúdo de um StringBuilder objeto:The StringBuilder class includes the following methods for expanding the contents of a StringBuilder object:

  • O Append método acrescenta uma cadeia de caracteres, uma Subcadeia, uma matriz de caracteres, uma parte de uma matriz de caracteres, um único caractere repetido várias vezes ou a representação de cadeia de caracteres de StringBuilder um tipo de dados primitivo para um objeto.The Append method appends a string, a substring, a character array, a portion of a character array, a single character repeated multiple times, or the string representation of a primitive data type to a StringBuilder object.

  • O AppendLine método anexa um terminador de linha ou uma cadeia de caracteres junto com um terminador de linha a um StringBuilder objeto.The AppendLine method appends a line terminator or a string along with a line terminator to a StringBuilder object.

  • O AppendFormat método anexa uma cadeia de caracteres de formato composto a um StringBuilder objeto.The AppendFormat method appends a composite format string to a StringBuilder object. As representações de cadeia de caracteres de objetos incluídas na cadeia de caracteres de resultado podem refletir as convenções de formatação da cultura do sistema atual ou de uma cultura especificada.The string representations of objects included in the result string can reflect the formatting conventions of the current system culture or a specified culture.

  • O Insert método insere uma cadeia de caracteres, uma subcadeia de caracteres, várias repetições de uma cadeia de caracteres, uma matriz de caracteres, uma parte de uma matriz de caracteres ou a representação de cadeia de caracteres de um StringBuilder tipo de dados primitivo em uma posição especificada no objeto.The Insert method inserts a string, a substring, multiple repetitions of a string, a character array, a portion of a character array, or the string representation of a primitive data type at a specified position in the StringBuilder object. A posição é definida por um índice baseado em zero.The position is defined by a zero-based index.

O exemplo a seguir usa Appendos AppendLinemétodos AppendFormat,, Insert e para expandir o texto de um StringBuilder objeto.The following example uses the Append, AppendLine, AppendFormat, and Insert methods to expand the text of a StringBuilder object.

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            <

Excluindo texto de um objeto StringBuilderDeleting text from a StringBuilder object

A StringBuilder classe inclui métodos que podem reduzir o tamanho da instância atual StringBuilder .The StringBuilder class includes methods that can reduce the size of the current StringBuilder instance. O Clear método remove todos os caracteres e define Length a propriedade como zero.The Clear method removes all characters and sets the Length property to zero. O Remove método exclui um número especificado de caracteres começando em uma determinada posição de índice.The Remove method deletes a specified number of characters starting at a particular index position. Além disso, você pode remover caracteres do final de um StringBuilder objeto definindo sua Length Propriedade com um valor menor que o comprimento da instância atual.In addition, you can remove characters from the end of a StringBuilder object by setting its Length property to a value that is less than the length of the current instance.

O exemplo a seguir remove parte do texto de um StringBuilder objeto, exibe sua capacidade resultante, capacidade máxima e valores de propriedade de comprimento e, em seguida Clear , chama o método para remover StringBuilder todos os caracteres do objeto.The following example removes some of the text from a StringBuilder object, displays its resulting capacity, maximum capacity, and length property values, and then calls the Clear method to remove all the characters from the StringBuilder object.

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

Alterando o texto em um objeto StringBuilderModifying the text in a StringBuilder object

O StringBuilder.Replace método substitui todas as ocorrências de um caractere ou uma cadeia de caracteres StringBuilder no objeto inteiro ou em um intervalo de caracteres específico.The StringBuilder.Replace method replaces all occurrences of a character or a string in the entire StringBuilder object or in a particular character range. O exemplo a seguir usa Replace o método para substituir todos os pontos de exclamação (!) com pontos de interrogação ( StringBuilder ?) no objeto.The following example uses the Replace method to replace all exclamation points (!) with question marks (?) in the StringBuilder object.

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?

Pesquisando o texto em um objeto StringBuilderSearching the text in a StringBuilder object

A StringBuilder classe não inclui métodos semelhantes String.Containsaos métodos, String.IndexOfe String.StartsWith fornecidos pela String classe, que permitem pesquisar o objeto em busca de um caractere específico ou de uma subcadeia de caracteres.The StringBuilder class does not include methods similar to the String.Contains, String.IndexOf, and String.StartsWith methods provided by the String class, which allow you to search the object for a particular character or a substring. Determinar a presença ou a posição de caracteres inicial de uma subcadeia de caracteres requer String que você pesquise um valor usando um método de pesquisa de cadeia de caracteres ou um método de expressão regular.Determining the presence or starting character position of a substring requires that you search a String value by using either a string search method or a regular expression method. Há quatro maneiras de implementar essas pesquisas, como mostra a tabela a seguir.There are four ways to implement such searches, as the following table shows.

TécnicaTechnique PrósPros ContrasCons
Pesquise valores de cadeia de caracteres antes de StringBuilder adicioná-los ao objeto.Search string values before adding them to the StringBuilder object. Útil para determinar se uma subcadeia de caracteres existe.Useful for determining whether a substring exists. Não pode ser usado quando a posição do índice de uma subcadeia de caracteres é importante.Cannot be used when the index position of a substring is important.
Chame ToString e pesquise o objeto String retornado.Call ToString and search the returned String object. Fácil de usar se você atribuir todo o texto a um StringBuilder objeto e começar a modificá-lo.Easy to use if you assign all the text to a StringBuilder object, and then begin to modify it. Difícil de chamar ToString repetidamente se você precisar fazer modificações antes que todo o StringBuilder texto seja adicionado ao objeto.Cumbersome to repeatedly call ToString if you must make modifications before all text is added to the StringBuilder object.

Você deve se lembrar de trabalhar no final do StringBuilder texto do objeto se estiver fazendo alterações.You must remember to work from the end of the StringBuilder object's text if you're making changes.
Use a Chars[Int32] propriedade para pesquisar um intervalo de caracteres em sequência.Use the Chars[Int32] property to sequentially search a range of characters. Útil se você estiver preocupado com caracteres individuais ou uma subcadeia de caracteres pequena.Useful if you're concerned with individual characters or a small substring. Incômodo se o número de caracteres a serem pesquisados for grande ou se a lógica de pesquisa for complexa.Cumbersome if the number of characters to search is large or if the search logic is complex.

Resulta em um desempenho muito ruim para objetos que cresceram muito muito por meio de chamadas de método repetidas.Results in very poor performance for objects that have grown very large through repeated method calls.
Converta StringBuilder o objeto em String um objeto String e execute modificações no objeto.Convert the StringBuilder object to a String object, and perform modifications on the String object. Útil se o número de modificações for pequeno.Useful if the number of modifications is small. Nega o benefício de desempenho da StringBuilder classe se o número de modificações for grande.Negates the performance benefit of the StringBuilder class if the number of modifications is large.

Vamos examinar essas técnicas com mais detalhes.Let's examine these techniques in greater detail.

  • Se a meta da pesquisa for determinar se existe uma subcadeia de caracteres específica (ou seja, se você não estiver interessado na posição da subcadeia de caracteres), poderá pesquisar cadeias de caracteres antes de StringBuilder armazená-las no objeto.If the goal of the search is to determine whether a particular substring exists (that is, if you aren't interested in the position of the substring), you can search strings before storing them in the StringBuilder object. O exemplo a seguir fornece uma implementação possível.The following example provides one possible implementation. Ele define uma StringBuilderFinder classe cujo construtor recebe uma referência a um StringBuilder objeto e a subcadeia de caracteres a ser encontrada na cadeia de caracteres.It defines a StringBuilderFinder class whose constructor is passed a reference to a StringBuilder object and the substring to find in the string. Nesse caso, o exemplo tenta determinar se as temperaturas gravadas estão em Fahrenheit ou Celsius e adiciona o texto introdutório apropriado ao início do StringBuilder objeto.In this case, the example tries to determine whether recorded temperatures are in Fahrenheit or Celsius, and adds the appropriate introductory text to the beginning of the StringBuilder object. Um gerador de números aleatórios é usado para selecionar uma matriz que contém dados em graus Celsius ou graus Fahrenheit.A random number generator is used to select an array that contains data in either degrees Celsius or degrees 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
    
  • Chame o StringBuilder.ToString método para converter o StringBuilder objeto em um String objeto.Call the StringBuilder.ToString method to convert the StringBuilder object to a String object. Você pode pesquisar a cadeia de caracteres usando métodos como String.LastIndexOf ou String.StartsWith, ou pode usar expressões regulares e a Regex classe para Pesquisar padrões.You can search the string by using methods such as String.LastIndexOf or String.StartsWith, or you can use regular expressions and the Regex class to search for patterns. Como os StringBuilder dois String objetos e usam a codificação UTF-16 para armazenar caracteres, as posições de índice de caracteres, subcadeias e correspondências de expressão regulares são as mesmas em ambos os objetos.Because both StringBuilder and String objects use UTF-16 encoding to store characters, the index positions of characters, substrings, and regular expression matches are the same in both objects. Isso permite que você use StringBuilder métodos para fazer alterações na mesma posição em que o texto é encontrado String no objeto.This enables you to use StringBuilder methods to make changes at the same position at which that text is found in the String object.

    Observação

    Se você adotar essa abordagem, deverá trabalhar no final do StringBuilder objeto até o início para que não seja preciso converter repetidamente o StringBuilder objeto em uma cadeia de caracteres.If you adopt this approach, you should work from the end of the StringBuilder object to its beginning so that you don't have to repeatedly convert the StringBuilder object to a string.

    O exemplo a seguir ilustra esta abordagem.The following example illustrates this approach. Ele armazena quatro ocorrências de cada letra do alfabeto em inglês em um StringBuilder objeto.It stores four occurrences of each letter of the English alphabet in a StringBuilder object. Em seguida, ele converte o texto String em um objeto e usa uma expressão regular para identificar a posição inicial de cada sequência de quatro caracteres.It then converts the text to a String object and uses a regular expression to identify the starting position of each four-character sequence. Por fim, ele adiciona um sublinhado antes de cada sequência de quatro caracteres, exceto para a primeira sequência, e converte o primeiro caractere da sequência em maiúsculas.Finally, it adds an underscore before each four-character sequence except for the first sequence, and converts the first character of the sequence to uppercase.

    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
    
  • Use a StringBuilder.Chars[Int32] propriedade para pesquisar em sequência um intervalo de caracteres em um StringBuilder objeto.Use the StringBuilder.Chars[Int32] property to sequentially search a range of characters in a StringBuilder object. Essa abordagem pode não ser prática se o número de caracteres a serem pesquisados for grande ou se a lógica de pesquisa for particularmente complexa.This approach may not be practical if the number of characters to be searched is large or the search logic is particularly complex. Para as implicações de desempenho do acesso baseado em índice caractere a caractere para StringBuilder objetos muito grandes e em partes, consulte a documentação StringBuilder.Chars[Int32] da propriedade.For the performance implications of character-by-character index-based access for very large, chunked StringBuilder objects, see the documentation for the StringBuilder.Chars[Int32] property.

    O exemplo a seguir é idêntico em funcionalidade ao exemplo anterior, mas difere na implementação.The following example is identical in functionality to the previous example but differs in implementation. Ele usa a Chars[Int32] propriedade para detectar quando um valor de caractere foi alterado, insere um sublinhado nessa posição e converte o primeiro caractere na nova sequência em maiúsculas.It uses the Chars[Int32] property to detect when a character value has changed, inserts an underscore at that position, and converts the first character in the new sequence to uppercase.

    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
    
  • Armazene todo o texto não modificado no StringBuilder objeto, chame o StringBuilder.ToString método para converter o StringBuilder objeto em um String objeto e execute as modificações no String objeto.Store all the unmodified text in the StringBuilder object, call the StringBuilder.ToString method to convert the StringBuilder object to a String object, and perform the modifications on the String object. Você pode usar essa abordagem se tiver apenas algumas modificações; caso contrário, o custo de trabalhar com cadeias de caracteres imutáveis pode negar os benefícios de desempenho StringBuilder do uso de um objeto.You can use this approach if you have only a few modifications; otherwise, the cost of working with immutable strings may negate the performance benefits of using a StringBuilder object.

    O exemplo a seguir é idêntico em funcionalidade aos dois exemplos anteriores, mas difere na implementação.The following example is identical in functionality to the previous two examples but differs in implementation. Ele cria um StringBuilder objeto, converte-o em String um objeto e, em seguida, usa uma expressão regular para executar todas as modificações restantes na cadeia de caracteres.It creates a StringBuilder object, converts it to a String object, and then uses a regular expression to perform all remaining modifications on the string. O Regex.Replace(String, String, MatchEvaluator) método usa uma expressão lambda para executar a substituição em cada correspondência.The Regex.Replace(String, String, MatchEvaluator) method uses a lambda expression to perform the replacement on each match.

    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
    

Convertendo o objeto StringBuilder em uma cadeia de caracteresConverting the StringBuilder object to a string

Você deve converter o objeto StringBuilder em um objeto Stringpara transmitir a cadeia de caracteres representada pelo objeto StringBuilder para um método que tem um parâmetro String ou exibi-lo na interface do usuário.You must convert the StringBuilder object to a String object before you can pass the string represented by the StringBuilder object to a method that has a String parameter or display it in the user interface. Você executa essa conversão chamando o StringBuilder.ToString método.You perform this conversion by calling the StringBuilder.ToString method. Para obter uma ilustração, consulte o exemplo anterior, que chama ToString o método para converter StringBuilder um objeto em uma cadeia de caracteres para que ele possa ser passado para um método de expressão regular.For an illustration, see the previous example, which calls the ToString method to convert a StringBuilder object to a string so that it can be passed to a regular expression method.

Notas aos Chamadores

No .NET Core e no .NET Framework 4,0 e versões posteriores, quando você instancia o StringBuilder objeto chamando o StringBuilder(Int32, Int32) Construtor, o comprimento StringBuilder e a capacidade da instância podem crescer além do valor de sua MaxCapacity Propriedade.In .NET Core and in the .NET Framework 4.0 and later versions, when you instantiate the StringBuilder object by calling the StringBuilder(Int32, Int32) constructor, both the length and the capacity of the StringBuilder instance can grow beyond the value of its MaxCapacity property. Isso pode ocorrer especialmente quando você chama os Append(String) métodos AppendFormat(String, Object) e para acrescentar cadeias de caracteres pequenas.This can occur particularly when you call the Append(String) and AppendFormat(String, Object) methods to append small strings.

Construtores

StringBuilder() StringBuilder() StringBuilder() StringBuilder()

Inicializa uma nova instância da classe StringBuilder.Initializes a new instance of the StringBuilder class.

StringBuilder(Int32) StringBuilder(Int32) StringBuilder(Int32) StringBuilder(Int32)

Inicializa uma nova instância da classe StringBuilder usando a capacidade especificada.Initializes a new instance of the StringBuilder class using the specified capacity.

StringBuilder(Int32, Int32) StringBuilder(Int32, Int32) StringBuilder(Int32, Int32) StringBuilder(Int32, Int32)

Inicializa uma nova instância da classe StringBuilder que começa com uma capacidade especificada e pode crescer até um máximo especificado.Initializes a new instance of the StringBuilder class that starts with a specified capacity and can grow to a specified maximum.

StringBuilder(String) StringBuilder(String) StringBuilder(String) StringBuilder(String)

Inicializa uma nova instância da classe StringBuilder usando a cadeia de caracteres especificada.Initializes a new instance of the StringBuilder class using the specified string.

StringBuilder(String, Int32) StringBuilder(String, Int32) StringBuilder(String, Int32) StringBuilder(String, Int32)

Inicializa uma nova instância da classe StringBuilder usando a cadeia de caracteres e a capacidade especificadas.Initializes a new instance of the StringBuilder class using the specified string and capacity.

StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32)

Inicializa uma nova instância da classe StringBuilder da capacidade e da subcadeia de caracteres especificada.Initializes a new instance of the StringBuilder class from the specified substring and capacity.

Propriedades

Capacity Capacity Capacity Capacity

Obtém ou define o número máximo de caracteres que podem ser contidos na memória alocada pela instância atual.Gets or sets the maximum number of characters that can be contained in the memory allocated by the current instance.

Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Obtém ou define o caractere na posição de caractere especificada nessa instância.Gets or sets the character at the specified character position in this instance.

Length Length Length Length

Obtém ou define o tamanho do objeto atual StringBuilder.Gets or sets the length of the current StringBuilder object.

MaxCapacity MaxCapacity MaxCapacity MaxCapacity

Obtém a capacidade máxima desta instância.Gets the maximum capacity of this instance.

Métodos

Append(Boolean) Append(Boolean) Append(Boolean) Append(Boolean)

Acrescenta a representação de cadeia de caracteres de um valor booliano especificado à essa instância.Appends the string representation of a specified Boolean value to this instance.

Append(Byte) Append(Byte) Append(Byte) Append(Byte)

Acrescenta a representação de cadeia de caracteres de um inteiro sem sinal de 8 bits especificado a essa instância.Appends the string representation of a specified 8-bit unsigned integer to this instance.

Append(Char) Append(Char) Append(Char) Append(Char)

Acrescenta a representação de cadeia de caracteres de um objeto Char especificado à essa instância.Appends the string representation of a specified Char object to this instance.

Append(Char*, Int32) Append(Char*, Int32) Append(Char*, Int32) Append(Char*, Int32)

Acrescenta uma matriz de caracteres Unicode começando em um endereço especificado a essa instância.Appends an array of Unicode characters starting at a specified address to this instance.

Append(Char, Int32) Append(Char, Int32) Append(Char, Int32) Append(Char, Int32)

Acrescenta um número de cópias especificado da representação de cadeia de caracteres de um caractere Unicode a essa instância.Appends a specified number of copies of the string representation of a Unicode character to this instance.

Append(Char[]) Append(Char[]) Append(Char[]) Append(Char[])

Acrescenta a representação de cadeia de caracteres dos caracteres Unicode em uma matriz especificada a essa instância.Appends the string representation of the Unicode characters in a specified array to this instance.

Append(Char[], Int32, Int32) Append(Char[], Int32, Int32) Append(Char[], Int32, Int32) Append(Char[], Int32, Int32)

Acrescenta a representação de cadeia de caracteres de uma submatriz especificada de caracteres Unicode à essa instância.Appends the string representation of a specified subarray of Unicode characters to this instance.

Append(Decimal) Append(Decimal) Append(Decimal) Append(Decimal)

Acrescenta a representação de cadeia de caracteres de um número decimal especificado à essa instância.Appends the string representation of a specified decimal number to this instance.

Append(Double) Append(Double) Append(Double) Append(Double)

Acrescenta a representação de cadeia de caracteres de um número de ponto flutuante de precisão dupla especificado a essa instância.Appends the string representation of a specified double-precision floating-point number to this instance.

Append(Int16) Append(Int16) Append(Int16) Append(Int16)

Acrescenta a representação de cadeia de caracteres de um inteiro com sinal de 16 bits especificado a essa instância.Appends the string representation of a specified 16-bit signed integer to this instance.

Append(Int32) Append(Int32) Append(Int32) Append(Int32)

Acrescenta a representação de cadeia de caracteres de um inteiro com sinal de 32 bits especificado a essa instância.Appends the string representation of a specified 32-bit signed integer to this instance.

Append(Int64) Append(Int64) Append(Int64) Append(Int64)

Acrescenta a representação de cadeia de caracteres de um inteiro com sinal de 64 bits especificado a essa instância.Appends the string representation of a specified 64-bit signed integer to this instance.

Append(Object) Append(Object) Append(Object) Append(Object)

Acrescenta a representação de cadeia de caracteres de um objeto especificado à essa instância.Appends the string representation of a specified object to this instance.

Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>)

Acrescenta a representação de cadeia de caracteres de uma região de memória do caractere somente leitura a essa instância.Appends the string representation of a specified read-only character memory region to this instance.

Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>)

Acrescenta a representação de cadeia de caracteres de um intervalo de caracteres somente leitura a essa instância.Appends the string representation of a specified read-only character span to this instance.

Append(SByte) Append(SByte) Append(SByte) Append(SByte)

Acrescenta a representação de cadeia de caracteres de um inteiro com sinal de 8 bits especificado a essa instância.Appends the string representation of a specified 8-bit signed integer to this instance.

Append(Single) Append(Single) Append(Single) Append(Single)

Acrescenta a representação de cadeia de caracteres de um número de ponto flutuante de precisão simples especificado a essa instância.Appends the string representation of a specified single-precision floating-point number to this instance.

Append(String) Append(String) Append(String) Append(String)

Acrescenta uma cópia da cadeia de caracteres especificada a essa instância.Appends a copy of the specified string to this instance.

Append(String, Int32, Int32) Append(String, Int32, Int32) Append(String, Int32, Int32) Append(String, Int32, Int32)

Acrescenta uma cópia de uma subcadeia de caracteres especificada a esta instância.Appends a copy of a specified substring to this instance.

Append(StringBuilder) Append(StringBuilder) Append(StringBuilder) Append(StringBuilder)

Acrescenta a representação de cadeia de caracteres de um construtor de cadeia de caracteres especificado a essa instância.Appends the string representation of a specified string builder to this instance.

Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32)

Acrescenta uma cópia de uma substring em um construtor de cadeia de caracteres especificado a essa instância.Appends a copy of a substring within a specified string builder to this instance.

Append(UInt16) Append(UInt16) Append(UInt16) Append(UInt16)

Acrescenta a representação de cadeia de caracteres de um inteiro sem sinal de 16 bits especificado a essa instância.Appends the string representation of a specified 16-bit unsigned integer to this instance.

Append(UInt32) Append(UInt32) Append(UInt32) Append(UInt32)

Acrescenta a representação de cadeia de caracteres de um inteiro sem sinal de 32 bits especificado a essa instância.Appends the string representation of a specified 32-bit unsigned integer to this instance.

Append(UInt64) Append(UInt64) Append(UInt64) Append(UInt64)

Acrescenta a representação de cadeia de caracteres de um inteiro sem sinal de 64 bits especificado a essa instância.Appends the string representation of a specified 64-bit unsigned integer to this instance.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um único argumento usando um provedor de formato especificado.Each format item is replaced by the string representation of a single argument using a specified format provider.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um de dois argumentos usando um provedor de formato especificado.Each format item is replaced by the string representation of either of two arguments using a specified format provider.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um de três argumentos usando um provedor de formato especificado.Each format item is replaced by the string representation of either of three arguments using a specified format provider.

AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[])

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de um argumento correspondente em uma matriz de parâmetro usando um provedor de formato especificado.Each format item is replaced by the string representation of a corresponding argument in a parameter array using a specified format provider.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um único argumento.Each format item is replaced by the string representation of a single argument.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um dos dois argumentos.Each format item is replaced by the string representation of either of two arguments.

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

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um dos três argumentos.Each format item is replaced by the string representation of either of three arguments.

AppendFormat(String, Object[]) AppendFormat(String, Object[]) AppendFormat(String, Object[]) AppendFormat(String, Object[])

Acrescenta a cadeia de caracteres retornada pelo processamento de uma cadeia de caracteres de formato composto, que contém zero ou mais itens de formato, a essa instância.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Cada item de formato é substituído pela representação de cadeia de caracteres de um argumento correspondente em uma matriz de parâmetros.Each format item is replaced by the string representation of a corresponding argument in a parameter array.

AppendJoin(Char, Object[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[])
AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[])
AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[])
AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[])
AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>)
AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>)
AppendLine() AppendLine() AppendLine() AppendLine()

Acrescenta o terminador de linha padrão ao final do atual objeto StringBuilder.Appends the default line terminator to the end of the current StringBuilder object.

AppendLine(String) AppendLine(String) AppendLine(String) AppendLine(String)

Acrescenta uma cópia da cadeia de caracteres especificada seguida pelo terminador de linha padrão para o fim do objeto StringBuilder atual.Appends a copy of the specified string followed by the default line terminator to the end of the current StringBuilder object.

Clear() Clear() Clear() Clear()

Remove todos os caracteres da instância StringBuilder atual.Removes all characters from the current StringBuilder instance.

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

Copia os caracteres de um segmento especificado desta instância para um segmento especificado de uma matriz Char de destino.Copies the characters from a specified segment of this instance to a specified segment of a destination Char array.

CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32)
EnsureCapacity(Int32) EnsureCapacity(Int32) EnsureCapacity(Int32) EnsureCapacity(Int32)

Garante que a capacidade desta instância do StringBuilder tenha pelo menos o valor especificado.Ensures that the capacity of this instance of StringBuilder is at least the specified value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>)

Retorna um valor que indica se os caracteres nessa instância são iguais aos caracteres em um intervalo de caracteres somente leitura especificado.Returns a value indicating whether the characters in this instance are equal to the characters in a specified read-only character span.

Equals(StringBuilder) Equals(StringBuilder) Equals(StringBuilder) Equals(StringBuilder)

Retorna um valor que indica se essa instância é igual a um objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

GetChunks() GetChunks() GetChunks() GetChunks()

Retorna um objeto que pode ser usado para iterar nas partes de caracteres representadas em um ReadOnlyMemory<Char> criado usando essa instância de StringBuilder.Returns an object that can be used to iterate through the chunks of characters represented in a ReadOnlyMemory<Char> created from this StringBuilder instance.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean)

Insere a representação de cadeia de caracteres de um valor booliano nessa instância na posição do caractere especificada.Inserts the string representation of a Boolean value into this instance at the specified character position.

Insert(Int32, Byte) Insert(Int32, Byte) Insert(Int32, Byte) Insert(Int32, Byte)

Insere a representação de cadeia de caracteres de um inteiro sem sinal de 8 bits especificado nessa instância na posição do caractere especificada.Inserts the string representation of a specified 8-bit unsigned integer into this instance at the specified character position.

Insert(Int32, Char) Insert(Int32, Char) Insert(Int32, Char) Insert(Int32, Char)

Insere a representação de cadeia de caracteres de um caractere Unicode especificado nessa instância na posição do caractere especificada.Inserts the string representation of a specified Unicode character into this instance at the specified character position.

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

Insere a representação de cadeia de caracteres de uma matriz de caracteres Unicode especificada nessa instância na posição do caractere especificada.Inserts the string representation of a specified array of Unicode characters into this instance at the specified character position.

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

Insere a representação de cadeia de caracteres de uma submatriz de caracteres Unicode especificada nessa instância na posição do caractere especificada.Inserts the string representation of a specified subarray of Unicode characters into this instance at the specified character position.

Insert(Int32, Decimal) Insert(Int32, Decimal) Insert(Int32, Decimal) Insert(Int32, Decimal)

Insere a representação de cadeia de caracteres de um número decimal nessa instância na posição do caractere especificada.Inserts the string representation of a decimal number into this instance at the specified character position.

Insert(Int32, Double) Insert(Int32, Double) Insert(Int32, Double) Insert(Int32, Double)

Insere a representação de cadeia de caracteres de um número de ponto flutuante de precisão dupla nessa instância na posição do caractere especificada.Inserts the string representation of a double-precision floating-point number into this instance at the specified character position.

Insert(Int32, Int16) Insert(Int32, Int16) Insert(Int32, Int16) Insert(Int32, Int16)

Insere a representação de cadeia de caracteres de um inteiro com sinal de 16 bits especificado nessa instância na posição do caractere especificada.Inserts the string representation of a specified 16-bit signed integer into this instance at the specified character position.

Insert(Int32, Int32) Insert(Int32, Int32) Insert(Int32, Int32) Insert(Int32, Int32)

Insere a representação de cadeia de caracteres de um inteiro com sinal de 32 bits especificado nessa instância na posição do caractere especificada.Inserts the string representation of a specified 32-bit signed integer into this instance at the specified character position.

Insert(Int32, Int64) Insert(Int32, Int64) Insert(Int32, Int64) Insert(Int32, Int64)

Insere a representação de cadeia de caracteres de um inteiro com sinal de 64 bits nessa instância na posição do caractere especificada.Inserts the string representation of a 64-bit signed integer into this instance at the specified character position.

Insert(Int32, Object) Insert(Int32, Object) Insert(Int32, Object) Insert(Int32, Object)

Insere a representação de cadeia de caracteres de um objeto nessa instância na posição do caractere especificada.Inserts the string representation of an object into this instance at the specified character position.

Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>)
Insert(Int32, SByte) Insert(Int32, SByte) Insert(Int32, SByte) Insert(Int32, SByte)

Insere a representação de cadeia de caracteres de um inteiro com sinal de 8 bits especificado nessa instância na posição do caractere especificada.Inserts the string representation of a specified 8-bit signed integer into this instance at the specified character position.

Insert(Int32, Single) Insert(Int32, Single) Insert(Int32, Single) Insert(Int32, Single)

Insere a representação de cadeia de caracteres de um número de ponto flutuante de precisão simples nessa instância na posição do caractere especificada.Inserts the string representation of a single-precision floating point number into this instance at the specified character position.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Insere uma cadeia de caracteres nesta instância na posição do caractere especificado.Inserts a string into this instance at the specified character position.

Insert(Int32, String, Int32) Insert(Int32, String, Int32) Insert(Int32, String, Int32) Insert(Int32, String, Int32)

Insere uma ou mais cópias de uma cadeia de caracteres especificada nesta instância na posição do caractere especificada.Inserts one or more copies of a specified string into this instance at the specified character position.

Insert(Int32, UInt16) Insert(Int32, UInt16) Insert(Int32, UInt16) Insert(Int32, UInt16)

Insere a representação de cadeia de caracteres de um inteiro sem sinal de 16 bits nessa instância na posição do caractere especificada.Inserts the string representation of a 16-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt32) Insert(Int32, UInt32) Insert(Int32, UInt32) Insert(Int32, UInt32)

Insere a representação de cadeia de caracteres de um inteiro sem sinal de 32 bits nessa instância na posição do caractere especificada.Inserts the string representation of a 32-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt64) Insert(Int32, UInt64) Insert(Int32, UInt64) Insert(Int32, UInt64)

Insere a representação de cadeia de caracteres de um inteiro sem sinal de 64 bits nessa instância na posição do caractere especificada.Inserts the string representation of a 64-bit unsigned integer into this instance at the specified character position.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Remove o intervalo especificado de caracteres dessa instância.Removes the specified range of characters from this instance.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Substitui todas as ocorrências de um caractere especificado nesta instância por outro caractere especificado.Replaces all occurrences of a specified character in this instance with another specified character.

Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32)

Substitui, dentro de uma subcadeia dessa instância, todas as ocorrências um caractere especificado por outro caractere especificado.Replaces, within a substring of this instance, all occurrences of a specified character with another specified character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Substitui todas as ocorrências de uma cadeia de caracteres especificada nesta instância por outra cadeia de caracteres especificada.Replaces all occurrences of a specified string in this instance with another specified string.

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32)

Substitui, dentro de uma subcadeia dessa instância, todas as ocorrências de uma cadeia de caracteres especificada por outra cadeia de caracteres especificada.Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.

ToString() ToString() ToString() ToString()

Converte o valor dessa instância em um String.Converts the value of this instance to a String.

ToString(Int32, Int32) ToString(Int32, Int32) ToString(Int32, Int32) ToString(Int32, Int32)

Converte o valor de uma subcadeia de caracteres dessa instância em um String.Converts the value of a substring of this instance to a String.

Implantações explícitas de interface

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para desserializar o objeto StringBuilder atual.Populates a SerializationInfo object with the data necessary to deserialize the current StringBuilder object.

Aplica-se a

Veja também