StringBuilder Klasa

Definicja

Reprezentuje modyfikowalny ciąg znaków. Klasa ta nie może być dziedziczona.

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

Przykłady

W poniższym przykładzie pokazano, jak wywołać wiele metod zdefiniowanych przez klasę StringBuilder .

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

Uwagi

Ta klasa reprezentuje obiekt przypominający ciąg, którego wartość jest niezmienną sekwencją znaków.

W tej sekcji:

Typy ciągów i typy StringBuilder

Chociaż StringBuilder obie String reprezentują sekwencje znaków, są implementowane inaczej. String jest niezmiennym typem. Oznacza to, że każda operacja, która wydaje się modyfikować String obiekt, faktycznie tworzy nowy ciąg.

Na przykład wywołanie String.Concat metody w poniższym przykładzie języka C# jest wyświetlane w celu zmiany wartości zmiennej ciągu o nazwie value. W rzeczywistości Concat metoda zwraca value obiekt, który ma inną wartość i adres z value obiektu, który został przekazany do metody. Należy pamiętać, że przykład należy skompilować przy użyciu opcji kompilatora /unsafe .

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

W przypadku procedur, które wykonują obszerne manipulowanie ciągami (takie jak aplikacje, które modyfikują ciąg wiele razy w pętli), modyfikowanie ciągu wielokrotnie może powodować znaczną karę za wydajność. Alternatywą jest użycie StringBuilderklasy , która jest niezmienną klasą ciągów. Niezmienność oznacza, że po utworzeniu wystąpienia klasy można go zmodyfikować, dołączając, usuwając, zastępując lub wstawiając znaki. Obiekt StringBuilder utrzymuje bufor w celu uwzględnienia rozszerzeń w ciągu. Nowe dane są dołączane do buforu, jeśli pokój jest dostępny; w przeciwnym razie zostanie przydzielony nowy, większy bufor, dane z oryginalnego buforu zostaną skopiowane do nowego buforu, a nowe dane zostaną następnie dołączone do nowego buforu.

Ważne

StringBuilder Chociaż klasa ogólnie zapewnia lepszą wydajność niż String klasa, nie należy automatycznie zastępować String wartością StringBuilder za każdym razem, gdy chcesz manipulować ciągami. Wydajność zależy od rozmiaru ciągu, ilości pamięci do przydzielenia dla nowego ciągu, systemu, na którym jest wykonywany kod, oraz typu operacji. Należy przygotować się do przetestowania kodu, aby określić, czy StringBuilder rzeczywiście oferuje znaczną poprawę wydajności.

Rozważ użycie String klasy w następujących warunkach:

  • Gdy liczba zmian, które kod wprowadzi w ciągu, jest mała. W takich przypadkach StringBuilder może oferować nieznaczne lub brak poprawy wydajności w porównaniu z usługą String.

  • Podczas wykonywania stałej liczby operacji łączenia, szczególnie w przypadku literałów ciągów. W takim przypadku kompilator może połączyć operacje łączenia w jedną operację.

  • Gdy podczas tworzenia ciągu trzeba wykonywać rozbudowane operacje wyszukiwania. Klasa StringBuilder nie ma metod wyszukiwania, takich jak IndexOf lub StartsWith. Musisz przekonwertować StringBuilder obiekt na String obiekt dla tych operacji i może to uniemożliwić korzystanie z wydajności przy użyciu polecenia StringBuilder. Aby uzyskać więcej informacji, zobacz sekcję Wyszukiwanie tekstu w obiekcie StringBuilder .

Rozważ użycie StringBuilder klasy w następujących warunkach:

  • Jeśli oczekujesz, że kod wprowadzi nieznaną liczbę zmian w ciągu w czasie projektowania (na przykład gdy używasz pętli do łączenia losowej liczby ciągów zawierających dane wejściowe użytkownika).

  • Jeśli oczekujesz, że kod wprowadzi znaczną liczbę zmian w ciągu.

Jak działa StringBuilder

Właściwość StringBuilder.Length wskazuje liczbę znaków, które StringBuilder aktualnie zawiera obiekt. Jeśli dodasz znaki do StringBuilder obiektu, jego długość zwiększa się, dopóki nie będzie równa rozmiarowi StringBuilder.Capacity właściwości, która definiuje liczbę znaków, które może zawierać obiekt. Jeśli liczba dodanych znaków powoduje StringBuilder przekroczenie bieżącej pojemności obiektu, zostanie przydzielona nowa pamięć, wartość Capacity właściwości zostanie podwoiona, nowe znaki zostaną dodane do StringBuilder obiektu, a jego Length właściwość zostanie skorygowana. Dodatkowa pamięć obiektu StringBuilder jest przydzielana dynamicznie, dopóki nie osiągnie wartości zdefiniowanej StringBuilder.MaxCapacity przez właściwość. Po osiągnięciu maksymalnej pojemności nie można przydzielić dodatkowej pamięci dla StringBuilder obiektu, a próba dodania znaków lub rozwinięcia jej poza maksymalną pojemność zgłasza ArgumentOutOfRangeException wyjątek lub wyjątek OutOfMemoryException .

W poniższym przykładzie pokazano, jak StringBuilder obiekt przydziela nową pamięć i dynamicznie zwiększa swoją pojemność, gdy ciąg przypisany do obiektu się rozwija. Kod tworzy StringBuilder obiekt, wywołując jego domyślny (bez parametrów) konstruktor. Domyślna pojemność tego obiektu to 16 znaków, a maksymalna pojemność to ponad 2 miliardy znaków. Dołączanie ciągu "To jest zdanie". powoduje utworzenie nowej alokacji pamięci, ponieważ długość ciągu (19 znaków) przekracza domyślną pojemność StringBuilder obiektu. Pojemność obiektu podwoi się do 32 znaków, zostanie dodany nowy ciąg, a długość obiektu wynosi teraz 19 znaków. Następnie kod dołącza ciąg "To jest dodatkowe zdanie". do wartości StringBuilder obiektu 11 razy. Za każdym razem, gdy operacja dołączania powoduje StringBuilder przekroczenie pojemności obiektu, jego istniejąca pojemność zostanie podwoiona, a Append operacja zakończy się pomyślnie.

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

Alokacja pamięci

Domyślna pojemność StringBuilder obiektu to 16 znaków, a domyślna maksymalna pojemność to Int32.MaxValue. Te wartości domyślne są używane w przypadku wywołania StringBuilder() konstruktorów i StringBuilder(String) .

Można jawnie zdefiniować początkową pojemność StringBuilder obiektu w następujący sposób:

  • Wywołując dowolny z StringBuilder konstruktorów, który zawiera capacity parametr podczas tworzenia obiektu.

  • Jawnie przypisując nową wartość do właściwości, StringBuilder.Capacity aby rozwinąć istniejący StringBuilder obiekt. Należy pamiętać, że właściwość zgłasza wyjątek, jeśli nowa pojemność jest mniejsza niż istniejąca pojemność lub większa niż StringBuilder maksymalna pojemność obiektu.

  • Wywołując metodę StringBuilder.EnsureCapacity z nową pojemnością. Nowa pojemność nie może być większa niż StringBuilder maksymalna pojemność obiektu. Jednak w przeciwieństwie do przypisania do Capacity właściwości nie zgłasza wyjątku, EnsureCapacity jeśli żądana nowa pojemność jest mniejsza niż istniejąca pojemność; w tym przypadku wywołanie metody nie ma wpływu.

Jeśli długość ciągu przypisanego do StringBuilder obiektu w wywołaniu konstruktora przekracza pojemność domyślną lub określoną pojemność, Capacity właściwość jest ustawiona na długość ciągu określonego z parametrem value .

Można jawnie zdefiniować maksymalną pojemność StringBuilder obiektu przez wywołanie konstruktora StringBuilder(Int32, Int32) . Nie można zmienić maksymalnej pojemności, przypisując nową wartość do MaxCapacity właściwości, ponieważ jest tylko do odczytu.

Jak pokazano w poprzedniej sekcji, gdy istniejąca pojemność jest niewystarczająca, zostanie przydzielona dodatkowa pamięć, a pojemność StringBuilder obiektu podwoi się do wartości zdefiniowanej MaxCapacity przez właściwość.

Ogólnie rzecz biorąc, domyślna pojemność i maksymalna pojemność są odpowiednie dla większości aplikacji. Możesz rozważyć ustawienie tych wartości w następujących warunkach:

  • Jeśli ostateczna wielkość StringBuilder obiektu może wzrosnąć znacznie częściej, zwykle przekracza kilka megabajtów. W takim przypadku może wystąpić pewna korzyść z wydajności dzięki ustawieniu właściwości początkowej Capacity na znacznie wysoką wartość, aby wyeliminować konieczność zbyt wielu reallokacji pamięci.

  • Jeśli kod jest uruchomiony w systemie z ograniczoną ilością pamięci. W takim przypadku warto rozważyć ustawienie MaxCapacity właściwości na mniejszą niż Int32.MaxValue w przypadku obsługi dużych ciągów, które mogą spowodować jego wykonanie w środowisku ograniczonym pamięci.

Utworzenie wystąpienia obiektu StringBuilder

Wystąpienie obiektu jest StringBuilder tworzone przez wywołanie jednego z sześciu przeciążonych konstruktorów klas, które są wymienione w poniższej tabeli. Trzy konstruktory tworzy wystąpienie StringBuilder obiektu, którego wartość jest pustym ciągiem, ale ustawiają jego Capacity wartości i MaxCapacity inaczej. Pozostałe trzy konstruktory definiują StringBuilder obiekt o określonej wartości ciągu i pojemności. Dwa z trzech konstruktorów używają domyślnej maksymalnej pojemności , Int32.MaxValuenatomiast trzecia umożliwia ustawienie maksymalnej pojemności.

Konstruktor Wartość ciągu Pojemność Maksymalna pojemność
StringBuilder() String.Empty 16 Int32.MaxValue
StringBuilder(Int32) String.Empty Zdefiniowane przez capacity parametr Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Zdefiniowane przez capacity parametr Zdefiniowane przez maxCapacity parametr
StringBuilder(String) Zdefiniowane przez value parametr 16 lub value. Length, w zależności od tego, która wartość jest większa Int32.MaxValue
StringBuilder(String, Int32) Zdefiniowane przez value parametr Zdefiniowane przez capacity parametr lub value. Length, w zależności od tego, która wartość jest większa. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) Zdefiniowane przez value. Substring(startIndex, length) Zdefiniowane przez capacity parametr lub value. Length, w zależności od tego, która wartość jest większa. Int32.MaxValue

W poniższym przykładzie użyto trzech przeciążeń tych konstruktorów do utworzenia wystąpień StringBuilder obiektów.

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

Wywołanie metod StringBuilder

Większość metod modyfikujących ciąg w wystąpieniu StringBuilder zwraca odwołanie do tego samego wystąpienia. Dzięki temu można wywoływać StringBuilder metody na dwa sposoby:

  • Możesz wykonać wywołania poszczególnych metod i zignorować wartość zwracaną, jak w poniższym przykładzie.

    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.
    
  • W jednej instrukcji można wykonać serię wywołań metod. Może to być wygodne, jeśli chcesz napisać pojedynczą instrukcję, która będzie łańcuchem kolejnych operacji. Poniższy przykład konsoliduje trzy wywołania metody z poprzedniego przykładu w jeden wiersz kodu.

    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.
    

Przeprowadzanie operacji StringBuilder

Metody klasy umożliwiają StringBuilder iterowanie, dodawanie, usuwanie lub modyfikowanie znaków w StringBuilder obiekcie.

Iterowanie znaków StringBuilder

Dostęp do znaków w StringBuilder obiekcie można uzyskać za pomocą StringBuilder.Chars[] właściwości . W języku C# Chars[] jest indeksatorem. W Visual Basic jest to domyślna właściwość StringBuilder klasy. Dzięki temu można ustawić lub pobrać poszczególne znaki tylko przy użyciu ich indeksu Chars[] bez jawnego odwoływania się do właściwości. Znaki w obiekcie zaczynają się od indeksu StringBuilder 0 (zero) i kontynuuj indeksowanie Length — 1.

Poniższy przykład ilustruje Chars[] właściwość . Dołącza dziesięć losowych liczb do StringBuilder obiektu, a następnie iteruje każdy znak. Jeśli kategoria Unicode znaku to UnicodeCategory.DecimalDigitNumber, zmniejsza liczbę o 1 (lub zmienia liczbę na 9, jeśli jej wartość wynosi 0). W przykładzie wyświetlana jest zawartość StringBuilder obiektu zarówno przed, jak i po zmianie wartości poszczególnych znaków.

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

Używanie indeksowania opartego na znakach z Chars[] właściwością może być niezwykle wolne w następujących warunkach:

Istotny wpływ na wydajność, ponieważ każdy dostęp do znaków analizuje całą połączoną listę fragmentów, aby znaleźć poprawny bufor do indeksowania.

Uwaga

Nawet w przypadku dużego obiektu "fragmentu" StringBuilder Używanie Chars[] właściwości dostępu opartego na indeksie do jednej lub małej liczby znaków ma niewielki wpływ na wydajność; zazwyczaj jest to 0 (n) operacja. Znaczący wpływ na wydajność występuje podczas iterowania znaków w StringBuilder obiekcie, który jest operacją o (n ^ 2) .

Jeśli wystąpią problemy z wydajnością podczas korzystania z indeksowania opartego na znakach z StringBuilder obiektami, można użyć dowolnego z następujących obejść:

  • Przekonwertuj StringBuilder wystąpienie na a String przez wywołanie ToString metody, a następnie uzyskaj dostęp do znaków w ciągu.

  • Skopiuj zawartość istniejącego StringBuilder obiektu do nowego obiektu przed rozmiarem StringBuilder . Zwiększona wydajność, ponieważ nowy StringBuilder obiekt nie jest fragmentem. Na przykład:

    // 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)
    
  • Ustaw początkową pojemność StringBuilder obiektu na wartość, która jest w przybliżeniu równa jego maksymalnemu oczekiwanemu rozmiarowi, wywołując StringBuilder(Int32) Konstruktor. Należy pamiętać, że to przypisuje cały blok pamięci, nawet jeśli StringBuilder rzadko osiągnie maksymalną pojemność.

Dodawanie tekstu do obiektu StringBuilder

Klasa StringBuilder zawiera następujące metody rozszerzania zawartości StringBuilder obiektu:

  • Metoda Append dołącza ciąg, podciąg, tablicę znaków, część tablicy znaków, pojedynczy znak powtarzany wiele razy lub reprezentację ciągu pierwotnego typu danych do StringBuilder obiektu.

  • Metoda AppendLine dołącza terminator linii lub ciąg wraz z terminatorem StringBuilder wiersza do obiektu.

  • Metoda AppendFormat dołącza ciąg formatu złożonego StringBuilder do obiektu. Reprezentacje ciągów obiektów zawartych w ciągu wynikowym mogą odzwierciedlać konwencje formatowania bieżącej kultury systemu lub określonej kultury.

  • Metoda Insert wstawia ciąg, podciąg, wiele powtórzeń ciągu, tablicę znaków, część tablicy znaków lub reprezentację ciągu pierwotnego typu danych na określonej pozycji w StringBuilder obiekcie. Pozycja jest definiowana przez indeks oparty na zerze.

W poniższym przykładzie użyto Appendmetod , AppendLine, AppendFormati Insert w celu rozwinięcia StringBuilder tekstu obiektu.

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            <

Usuwanie tekstu z obiektu StringBuilder

Klasa StringBuilder zawiera metody, które mogą zmniejszyć rozmiar bieżącego StringBuilder wystąpienia. Metoda Clear usuwa wszystkie znaki i ustawia Length właściwość na zero. Metoda Remove usuwa określoną liczbę znaków, zaczynając od określonej pozycji indeksu. Ponadto można usunąć znaki z końca StringBuilder obiektu, ustawiając jego Length właściwość na wartość mniejszą niż długość bieżącego wystąpienia.

Poniższy przykład usuwa część tekstu z StringBuilder obiektu, wyświetla jego wynikową pojemność, maksymalną pojemność i wartości właściwości długości, a następnie wywołuje metodę Clear , aby usunąć wszystkie znaki z StringBuilder obiektu.

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

Modyfikowanie tekstu w obiekcie StringBuilder

Metoda StringBuilder.Replace zastępuje wszystkie wystąpienia znaku lub ciągu w całym StringBuilder obiekcie lub w określonym zakresie znaków. W poniższym przykładzie użyto Replace metody , aby zastąpić wszystkie wykrzykniki (!) znakami zapytania (?) w StringBuilder obiekcie.

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?

Wyszukiwanie tekstu w obiekcie StringBuilder

Klasa StringBuilder nie zawiera metod podobnych do String.Containsmetod , String.IndexOfi String.StartsWith dostarczonych przez String klasę, które umożliwiają wyszukiwanie obiektu dla określonego znaku lub podciągów. Określenie obecności lub pozycji początkowego znaku podciągów wymaga przeszukania String wartości przy użyciu metody wyszukiwania ciągów lub metody wyrażenia regularnego. Istnieją cztery sposoby implementowania takich wyszukiwań, jak pokazano w poniższej tabeli.

Technika Zalety Wady
Wyszukaj wartości ciągu przed dodaniem ich do StringBuilder obiektu. Przydatne do określania, czy podciąg istnieje. Nie można użyć, gdy pozycja indeksu podciągów jest ważna.
Wywołaj ToString i przeszukaj zwrócony String obiekt. Łatwość użycia, jeśli przypiszesz cały tekst do StringBuilder obiektu, a następnie zaczniesz go modyfikować. Kłopotliwe wywołanie ToString metody , jeśli musisz wprowadzić modyfikacje przed dodaniu całego tekstu do StringBuilder obiektu.

Pamiętaj, aby pracować od końca StringBuilder tekstu obiektu, jeśli wprowadzasz zmiany.
Użyj właściwości , Chars[] aby sekwencyjnie przeszukiwać zakres znaków. Przydatne, jeśli chodzi o poszczególne znaki lub mały podciąg. Kłopotliwe, jeśli liczba znaków do wyszukania jest duża lub jeśli logika wyszukiwania jest złożona.

Skutkuje bardzo niską wydajnością obiektów, które wzrosły bardzo duże za pomocą powtarzających się wywołań metod.
Przekonwertuj StringBuilder obiekt na String obiekt i przeprowadź modyfikacje obiektu String . Przydatne, jeśli liczba modyfikacji jest mała. Neguje korzyść StringBuilder z wydajności klasy, jeśli liczba modyfikacji jest duża.

Przyjrzyjmy się tym technikom bardziej szczegółowo.

  • Jeśli celem wyszukiwania jest określenie, czy określony podciąg istnieje (czyli jeśli nie interesuje Cię pozycja podciągów), możesz wyszukiwać ciągi przed zapisaniem ich w StringBuilder obiekcie. Poniższy przykład przedstawia jedną z możliwych implementacji. Definiuje klasę StringBuilderFinder , której konstruktor jest przekazywany odwołanie do StringBuilder obiektu i podciąg do znalezienia w ciągu. W tym przypadku przykład próbuje określić, czy zarejestrowane temperatury znajdują się w fahrenheita czy stopni Celsjusza, i dodaje odpowiedni tekst wprowadzający na początku StringBuilder obiektu. Generator liczb losowych służy do wybierania tablicy zawierającej dane w stopniach Celsjusza lub stopniach Fahrenheita.

    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
    
  • Wywołaj metodę , StringBuilder.ToString aby przekonwertować StringBuilder obiekt na String obiekt. Ciąg można przeszukiwać przy użyciu metod, takich jak String.LastIndexOf lub String.StartsWith, lub można użyć wyrażeń regularnych i Regex klasy do wyszukiwania wzorców. Ponieważ oba StringBuilder obiekty i String używają kodowania UTF-16 do przechowywania znaków, pozycje indeksu znaków, podciągów i dopasowań wyrażeń regularnych są takie same w obu obiektach. Dzięki temu można używać StringBuilder metod do wprowadzania zmian w tej samej pozycji, w której znajduje się ten tekst w String obiekcie.

    Uwaga

    Jeśli zastosujesz to podejście, należy pracować od końca StringBuilder obiektu do jego początku, aby nie trzeba było wielokrotnie konwertować StringBuilder obiektu na ciąg.

    To podejście pokazano w poniższym przykładzie. Przechowuje cztery wystąpienia każdej litery alfabetu angielskiego w StringBuilder obiekcie. Następnie konwertuje tekst na String obiekt i używa wyrażenia regularnego do identyfikowania pozycji początkowej każdej sekwencji czterech znaków. Na koniec dodaje znak podkreślenia przed każdą czteroznakową sekwencją z wyjątkiem pierwszej sekwencji i konwertuje pierwszy znak sekwencji na wielkie litery.

    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
    
  • Użyj właściwości , StringBuilder.Chars[] aby sekwencyjnie przeszukiwać zakres znaków w StringBuilder obiekcie. Takie podejście może nie być praktyczne, jeśli liczba wyszukiwanych znaków jest duża lub logika wyszukiwania jest szczególnie złożona. Aby uzyskać wpływ na wydajność dostępu opartego na znakach według znaków dla bardzo dużych, fragmentowanych StringBuilder obiektów, zapoznaj się z dokumentacją StringBuilder.Chars[] właściwości .

    Poniższy przykład jest identyczny w funkcjonalności z poprzednim przykładem, ale różni się implementacją. Używa Chars[] właściwości do wykrywania, kiedy wartość znaku uległa zmianie, wstawia podkreślenie na tej pozycji i konwertuje pierwszy znak w nowej sekwencji na wielkie litery.

    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
    
  • Zapisz cały niezmodyfikowany tekst w StringBuilder obiekcie, wywołaj StringBuilder.ToString metodę , aby przekonwertować StringBuilder obiekt na String obiekt i wykonać modyfikacje obiektu String . Tego podejścia można użyć, jeśli masz tylko kilka modyfikacji; w przeciwnym razie koszt pracy z niezmienialnymi ciągami może negować korzyści z wydajności wynikające z używania StringBuilder obiektu.

    Poniższy przykład jest identyczny w funkcjonalności z poprzednimi dwoma przykładami, ale różni się implementacją. StringBuilder Tworzy obiekt, konwertuje go na String obiekt, a następnie używa wyrażenia regularnego do wykonania wszystkich pozostałych modyfikacji w ciągu. Metoda Regex.Replace(String, String, MatchEvaluator) używa wyrażenia lambda do wykonania zamiany na każdym dopasowaniu.

    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
    

Konwersja obiektu StringBuilder na ciąg

Należy przekonwertować StringBuilder obiekt na String obiekt przed przekazaniem ciągu reprezentowanego przez StringBuilder obiekt do metody, która ma String parametr lub wyświetlić go w interfejsie użytkownika. Ta konwersja jest wykonywana przez wywołanie StringBuilder.ToString metody . Aby zapoznać się z ilustracją, zobacz poprzedni przykład, który wywołuje ToString metodę , aby przekonwertować StringBuilder obiekt na ciąg, aby można było przekazać go do metody wyrażenia regularnego.

Uwagi dotyczące wywoływania

Na platformie .NET Core i w .NET Framework 4.0 i nowszych wersjach podczas tworzenia wystąpienia StringBuilder obiektu przez wywołanie StringBuilder(Int32, Int32) konstruktora zarówno długość, jak i pojemność StringBuilder wystąpienia mogą wzrosnąć poza wartość jego MaxCapacity właściwości. Może to wystąpić szczególnie w przypadku wywołania Append(String) metod i AppendFormat(String, Object) w celu dołączenia małych ciągów.

Konstruktory

StringBuilder()

Inicjuje nowe wystąpienie klasy StringBuilder.

StringBuilder(Int32)

Inicjuje StringBuilder nowe wystąpienie klasy przy użyciu określonej pojemności.

StringBuilder(Int32, Int32)

Inicjuje StringBuilder nowe wystąpienie klasy rozpoczynającej się od określonej pojemności i może wzrosnąć do określonej wartości maksymalnej.

StringBuilder(String)

Inicjuje StringBuilder nowe wystąpienie klasy przy użyciu określonego ciągu.

StringBuilder(String, Int32)

Inicjuje StringBuilder nowe wystąpienie klasy przy użyciu określonego ciągu i pojemności.

StringBuilder(String, Int32, Int32, Int32)

Inicjuje StringBuilder nowe wystąpienie klasy z określonego podciągu i pojemności.

Właściwości

Capacity

Pobiera lub ustawia maksymalną liczbę znaków, które mogą być zawarte w pamięci przydzielonej przez bieżące wystąpienie.

Chars[Int32]

Pobiera lub ustawia znak w określonej pozycji znaku w tym wystąpieniu.

Length

Pobiera lub ustawia długość bieżącego StringBuilder obiektu.

MaxCapacity

Pobiera maksymalną pojemność tego wystąpienia.

Metody

Append(Boolean)

Dołącza do tego wystąpienia reprezentację ciągu określonej wartości logicznej.

Append(Byte)

Dołącza do tego wystąpienia reprezentację ciągu określonej 8-bitowej liczby całkowitej bez znaku.

Append(Char)

Dołącza do tego wystąpienia reprezentację ciągu określonego Char obiektu.

Append(Char*, Int32)

Dołącza tablicę znaków Unicode rozpoczynających się od określonego adresu do tego wystąpienia.

Append(Char, Int32)

Dołącza określoną liczbę kopii ciągu reprezentującego znak Unicode do tego wystąpienia.

Append(Char[])

Dołącza do tego wystąpienia reprezentację ciągów znaków Unicode w określonej tablicy.

Append(Char[], Int32, Int32)

Dołącza do tego wystąpienia reprezentację ciągu określonej podtablicy znaków Unicode.

Append(Decimal)

Dołącza do tego wystąpienia reprezentację ciągu określonej liczby dziesiętnej.

Append(Double)

Dołącza do tego wystąpienia reprezentację ciągu określonej liczby zmiennoprzecinkowa o podwójnej precyzji.

Append(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

Dołącza określony ciąg interpolowany do tego wystąpienia przy użyciu określonego formatu.

Append(Int16)

Dołącza do tego wystąpienia reprezentację ciągu określonej 16-bitowej liczby całkowitej ze znakiem.

Append(Int32)

Dołącza do tego wystąpienia reprezentację ciągu określonej 32-bitowej liczby całkowitej ze znakiem.

Append(Int64)

Dołącza do tego wystąpienia reprezentację ciągu określonej 64-bitowej liczby całkowitej ze znakiem.

Append(Object)

Dołącza do tego wystąpienia reprezentację ciągu określonego obiektu.

Append(ReadOnlyMemory<Char>)

Dołącza do tego wystąpienia reprezentację ciągu określonego regionu pamięci znaków tylko do odczytu.

Append(ReadOnlySpan<Char>)

Dołącza do tego wystąpienia reprezentację ciągu określonego zakresu znaków tylko do odczytu.

Append(SByte)

Dołącza do tego wystąpienia reprezentację ciągu określonej 8-bitowej liczby całkowitej ze znakiem.

Append(Single)

Dołącza do tego wystąpienia reprezentację ciągu określonej liczby zmiennoprzecinkowa o pojedynczej precyzji.

Append(String)

Dołącza kopię określonego ciągu do tego wystąpienia.

Append(String, Int32, Int32)

Dołącza kopię określonego podciągu do tego wystąpienia.

Append(StringBuilder)

Dołącza do tego wystąpienia reprezentację ciągu określonego konstruktora ciągów.

Append(StringBuilder, Int32, Int32)

Dołącza kopię podciągów w określonym konstruktorze ciągów do tego wystąpienia.

Append(StringBuilder+AppendInterpolatedStringHandler)

Dołącza określony ciąg interpolowany do tego wystąpienia.

Append(UInt16)

Dołącza do tego wystąpienia reprezentację ciągu określonej 16-bitowej liczby całkowitej bez znaku.

Append(UInt32)

Dołącza do tego wystąpienia reprezentację ciągu określonej 32-bitowej liczby całkowitej bez znaku.

Append(UInt64)

Dołącza do tego wystąpienia reprezentację ciągu określonej 64-bitowej liczby całkowitej bez znaku.

AppendFormat(IFormatProvider, String, Object)

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu pojedynczego argumentu przy użyciu określonego dostawcy formatu.

AppendFormat(IFormatProvider, String, Object, Object)

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu jednego z dwóch argumentów przy użyciu określonego dostawcy formatu.

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

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu jednego z trzech argumentów przy użyciu określonego dostawcy formatu.

AppendFormat(IFormatProvider, String, Object[])

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu odpowiedniego argumentu w tablicy parametrów przy użyciu określonego dostawcy formatu.

AppendFormat(String, Object)

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu pojedynczego argumentu.

AppendFormat(String, Object, Object)

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu jednego z dwóch argumentów.

AppendFormat(String, Object, Object, Object)

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu jednego z trzech argumentów.

AppendFormat(String, Object[])

Dołącza ciąg zwracany przez przetwarzanie ciągu formatu złożonego, który zawiera zero lub więcej elementów formatu, do tego wystąpienia. Każdy element formatu jest zastępowany przez reprezentację ciągu odpowiadającego argumentu w tablicy parametrów.

AppendJoin(Char, Object[])

Łączy reprezentacje ciągów elementów w podanej tablicy obiektów przy użyciu określonego separatora znaków między poszczególnymi elementami członkowskim, a następnie dołącza wynik do bieżącego wystąpienia konstruktora ciągów.

AppendJoin(Char, String[])

Łączy ciągi podanej tablicy przy użyciu określonego separatora znaków między poszczególnymi ciągami, a następnie dołącza wynik do bieżącego wystąpienia konstruktora ciągów.

AppendJoin(String, Object[])

Łączy reprezentacje ciągów elementów w podanej tablicy obiektów przy użyciu określonego separatora między poszczególnymi elementami członkowskim, a następnie dołącza wynik do bieżącego wystąpienia konstruktora ciągów.

AppendJoin(String, String[])

Łączy ciągi podanej tablicy przy użyciu określonego separatora między poszczególnymi ciągami, a następnie dołącza wynik do bieżącego wystąpienia konstruktora ciągów.

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

Łączy i dołącza elementy członkowskie kolekcji przy użyciu określonego separatora znaków między każdym elementem członkowskim.

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

Łączy i dołącza elementy członkowskie kolekcji przy użyciu określonego separatora między poszczególnymi elementami członkowskim.

AppendLine()

Dołącza domyślny terminator wiersza na końcu bieżącego StringBuilder obiektu.

AppendLine(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

Dołącza określony ciąg interpolowany przy użyciu określonego formatu, a następnie domyślny terminator wiersza na końcu bieżącego obiektu StringBuilder.

AppendLine(String)

Dołącza kopię określonego ciągu, po której następuje domyślny terminator wiersza na końcu bieżącego StringBuilder obiektu.

AppendLine(StringBuilder+AppendInterpolatedStringHandler)

Dołącza określony ciąg interpolowany, po którym następuje domyślny terminator wiersza na końcu bieżącego obiektu StringBuilder.

Clear()

Usuwa wszystkie znaki z bieżącego StringBuilder wystąpienia.

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

Kopiuje znaki z określonego segmentu tego wystąpienia do określonego segmentu tablicy docelowej Char .

CopyTo(Int32, Span<Char>, Int32)

Kopiuje znaki z określonego segmentu tego wystąpienia do zakresu docelowego Char .

EnsureCapacity(Int32)

Zapewnia, że pojemność tego wystąpienia programu StringBuilder jest co najmniej określoną wartością.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
Equals(ReadOnlySpan<Char>)

Zwraca wartość wskazującą, czy znaki w tym wystąpieniu są równe znakom w określonym zakresie znaków tylko do odczytu.

Equals(StringBuilder)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

GetChunks()

Zwraca obiekt, który może służyć do iterowania fragmentów znaków reprezentowanych w utworzonym ReadOnlyMemory<Char> na podstawie tego StringBuilder wystąpienia.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
Insert(Int32, Boolean)

Wstawia reprezentację ciągu wartości logicznej w tym wystąpieniu w określonym położeniu znaku.

Insert(Int32, Byte)

Wstawia reprezentację ciągu określonej 8-bitowej liczby całkowitej bez znaku do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Char)

Wstawia do tego wystąpienia reprezentację ciągu określonego znaku Unicode w określonym położeniu znaku.

Insert(Int32, Char[])

Wstawia reprezentację ciągu określonej tablicy znaków Unicode do tego wystąpienia w określonym położeniu znaku.

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

Wstawia reprezentację ciągu określonej podtablicy znaków Unicode do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Decimal)

Wstawia reprezentację ciągu liczby dziesiętnej do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Double)

Wstawia reprezentację ciągu liczby zmiennoprzecinkowych o podwójnej precyzji do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Int16)

Wstawia reprezentację ciągu określonej 16-bitowej liczby całkowitej ze znakiem do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Int32)

Wstawia reprezentację ciągu określonej 32-bitowej liczby całkowitej ze znakiem do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, Int64)

Wstawia reprezentację ciągu 64-bitowej liczby całkowitej ze znakiem w tym wystąpieniu w określonym położeniu znaku.

Insert(Int32, Object)

Wstawia reprezentację ciągu obiektu w tym wystąpieniu w określonym położeniu znaku.

Insert(Int32, ReadOnlySpan<Char>)

Wstawia sekwencję znaków do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, SByte)

Wstawia reprezentację ciągu określonej 8-bitowej liczby całkowitej ze znakiem w tym wystąpieniu na określonej pozycji znaku.

Insert(Int32, Single)

Wstawia reprezentację ciągu liczby zmiennoprzecinkowych o pojedynczej precyzji do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, String)

Wstawia ciąg do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, String, Int32)

Wstawia co najmniej jedną kopię określonego ciągu do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, UInt16)

Wstawia reprezentację ciągu 16-bitowej liczby całkowitej bez znaku do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, UInt32)

Wstawia reprezentację ciągu 32-bitowej liczby całkowitej bez znaku do tego wystąpienia w określonym położeniu znaku.

Insert(Int32, UInt64)

Wstawia reprezentację ciągu 64-bitowej liczby całkowitej bez znaku do tego wystąpienia w określonym położeniu znaku.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Remove(Int32, Int32)

Usuwa określony zakres znaków z tego wystąpienia.

Replace(Char, Char)

Zamienia wszystkie wystąpienia określonego znaku w tym wystąpieniu na inny określony znak.

Replace(Char, Char, Int32, Int32)

Zamienia w podciąg tego wystąpienia wszystkie wystąpienia określonego znaku na inny określony znak.

Replace(String, String)

Zamienia wszystkie wystąpienia określonego ciągu w tym wystąpieniu na inny określony ciąg.

Replace(String, String, Int32, Int32)

Zamienia w podciąg tego wystąpienia wszystkie wystąpienia określonego ciągu na inny określony ciąg.

ToString()

Konwertuje wartość tego wystąpienia na wartość String.

ToString(Int32, Int32)

Konwertuje wartość podciągów tego wystąpienia na wartość String.

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo Wypełnia obiekt danymi niezbędnymi do deserializacji bieżącego StringBuilder obiektu.

Dotyczy

Zobacz też