StringBuilder 类

定义

表示可变字符字符串。 此类不能被继承。

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
继承
StringBuilder
属性
实现

示例

下面的示例演示如何调用类定义的多个方法 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

注解

此类表示一个类似字符串的对象,其值为可变的字符序列。

本部分内容:

String 和 StringBuilder 类型

尽管 StringBuilder String 和 都表示字符序列,但实现方式不同。 String 是一种不可变类型。 也就是说,似乎要修改 对象的每个 String 操作实际上都创建了一个新字符串。

例如,以下 C# 示例中对 方法的调用似乎更改名为 String.Concat 的字符串变量的值 value 。 实际上, 方法返回一个 对象,该对象的值和地址与传递给 Concat value value 方法的 对象不同。 请注意,必须使用 编译器选项编译 /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

对于执行大量字符串操作 (如在循环中多次修改字符串的应用) 重复修改字符串可能会严重降低性能。 替代方法是使用 StringBuilder ,它是可变字符串类。 可变性是指创建 类的实例后,可以通过追加、删除、替换或插入字符来对其进行修改。 StringBuilder对象维护缓冲区以容纳对字符串的扩展。 如果空间可用,则新数据将追加到缓冲区中;否则,将分配一个新的更大的缓冲区,将原始缓冲区的数据复制到新缓冲区,然后将新数据追加到新缓冲区。

重要

虽然 类通常提供比 类更好的性能,但每当你想要操作字符串时,都不应 StringBuilder String String StringBuilder 自动将 替换为 。 性能取决于字符串的大小、要分配给新字符串的内存量、执行代码的系统以及操作类型。 应准备好测试代码,以确定 StringBuilder 实际是否提供显著的性能改进。

请考虑在 String 以下条件下使用 类:

  • 当代码对字符串所做的更改数较小时。 在这些情况下, StringBuilder 的性能可能会比 提供可忽略不计的提升,或者没有性能改进 String

  • 执行固定数量的串联操作时,尤其是使用字符串文本时。 在这种情况下,编译器可能会将串联操作合并为单个操作。

  • 在生成字符串时必须执行大量搜索操作时。 StringBuilder类缺少搜索方法,如 IndexOfStartsWith 。 对于这些操作,你必须将 对象转换为 ,这可能会否定 StringBuilder String 使用 的性能优势 StringBuilder 。 有关详细信息,请参阅 在 StringBuilder 对象中搜索文本 部分。

请考虑在 StringBuilder 以下条件下使用 类:

  • 当你期望代码在设计时对字符串进行未知数量的更改时 (例如,使用 循环连接包含用户输入字符串的随机数量的字符串时) 。

  • 当你期望代码对字符串进行大量更改时。

StringBuilder 的工作原理

StringBuilder.Length属性指示对象当前包含 StringBuilder 的字符数。 如果将字符添加到 对象,则其长度会增大,直到它等于 属性的大小,该属性定义对象可以包含 StringBuilder StringBuilder.Capacity 的字符数。 如果添加的字符数导致对象的长度超过其当前容量,则分配新内存,将属性的值增加一倍,向对象添加新字符,并调整其 StringBuilder Capacity StringBuilder Length 属性。 对象的额外 StringBuilder 内存将动态分配,直到它达到 由 属性定义 StringBuilder.MaxCapacity 的值。 达到最大容量时,无法为对象分配更多内存,尝试添加字符或将其扩展到其最大容量之外会引发 或 StringBuilder ArgumentOutOfRangeException OutOfMemoryException 异常。

下面的示例演示对象如何分配新内存,并随着分配给该对象的字符串的扩展动态增加 StringBuilder 其容量。 该代码通过调用无 StringBuilder 参数构造函数 (创建) 对象。 此对象的默认容量为 16 个字符,其最大容量超过 20 亿个字符。 追加字符串"这是一个句子"。 导致新的内存分配,因为字符串长度 (19 个字符) 超过对象的默认 StringBuilder 容量。 对象的容量翻倍到 32 个字符,添加了新字符串,对象的长度现在等于 19 个字符。 然后,代码将追加字符串"这是一个附加句子"。 到 对象值 StringBuilder 11 次。 每当追加操作导致对象的长度超过其容量时,其现有容量就会增加一 StringBuilder 倍, Append 操作就会成功。

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

内存分配

对象的默认容量为 StringBuilder 16 个字符,其默认最大容量为 Int32.MaxValue 。 如果调用 和 构造函数,则使用这些 StringBuilder() StringBuilder(String) 默认值。

可以通过以下方式显式定义 StringBuilder 对象的初始容量:

如果分配给构造函数调用中的 对象的字符串的长度超过了默认容量或指定容量,则 属性将设置为使用 参数 StringBuilder Capacity 指定的字符串 value 的长度。

可以通过调用 构造函数显式定义 对象 StringBuilder 的最大 StringBuilder(Int32, Int32) 容量。 无法通过向 属性分配新值来更改最大容量 MaxCapacity ,因为它是只读的。

如上一部分所示,每当现有容量不足时,就会分配额外的内存,并且对象的容量会翻倍到 属性 StringBuilder 定义的 MaxCapacity 值。

通常,默认容量和最大容量足以满足大多数应用需求。 可以考虑在下列条件下设置这些值:

  • 如果对象的最终大小可能会增长到过大 StringBuilder ,通常超过几兆字节。 在这种情况下,将初始属性设置为一个明显高的值可能会带来一些性能优势,从而消除过多 Capacity 内存重新分配需求。

  • 如果代码在内存有限的系统上运行。 在这种情况下,可能需要考虑将 属性设置为小于如果代码正在处理可能导致它在内存受限的环境中执行的大型 MaxCapacity Int32.MaxValue 字符串。

实例化 StringBuilder 对象

通过调用其六个重载类构造函数之一来实例化 对象,下表中列出了 StringBuilder 这些构造函数。 三个构造函数实例化其值为空字符串的 对象,但以不同方式设置其 StringBuilder CapacityMaxCapacity 值。 其余三个构造函数定义 StringBuilder 一个对象,该对象具有特定的字符串值和容量。 三个构造函数中的两个使用 的默认最大容量 Int32.MaxValue ,而第三个构造函数允许你设置最大容量。

构造函数 字符串值 容量 最大容量
StringBuilder() String.Empty 16 Int32.MaxValue
StringBuilder(Int32) String.Empty 由 参数 capacity 定义 Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty 由 参数 capacity 定义 由 参数 maxCapacity 定义
StringBuilder(String) 由 参数 value 定义 16 或 valueLength,以较大者为准 Int32.MaxValue
StringBuilder(String, Int32) 由 参数 value 定义 由 参数 capacity 或 定义 valueLength,以较大者为准。 Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) value 定义。 Substring(startIndex, length) 由 参数 capacity 或 定义 valueLength,以较大者为准。 Int32.MaxValue

下面的示例使用三个构造函数重载来实例化 StringBuilder 对象。

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

调用 StringBuilder 方法

修改实例中的字符串的大多数方法都将 StringBuilder 返回对同一实例的引用。 这使您可以通过 StringBuilder 两种方式调用方法:

  • 可以进行单个方法调用并忽略返回值,如下例所示。

    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.
    
  • 可以在单个语句中执行一系列方法调用。 如果要编写一条链接连续操作的语句,这会很方便。 下面的示例将上一示例中的三个方法调用合并为单个代码行。

    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.
    

执行 StringBuilder 操作

您可以使用类的方法 StringBuilder 来循环访问、添加、删除或修改对象中的字符 StringBuilder

迭代 StringBuilder 字符

可以 StringBuilder 通过使用属性访问对象中的字符 StringBuilder.Chars[] 。 在 c # 中, Chars[] 是索引器; 在 Visual Basic 中,它是类的默认属性 StringBuilder 。 这使您可以仅使用索引来设置或检索单个字符,而无需显式引用 Chars[] 属性。 对象中的字符从 StringBuilder 索引0开始 (零) 并继续到索引 Length -1。

下面的示例阐释了 Chars[] 属性。 它将10个随机数追加到 StringBuilder 对象,然后循环访问每个字符。 如果该字符的 Unicode 类别为 UnicodeCategory.DecimalDigitNumber ,则将该数字减小 1 (或者将其值为 0) 将其更改为9。 此示例在 StringBuilder 更改各个字符的值之前和之后都显示对象的内容。

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

在以下情况下,通过 Chars[] 属性使用基于字符的索引可能会非常缓慢:

因为每次字符访问都会遍历区块的整个链接列表以查找要索引到的正确缓冲区,所以性能受到严重影响。

备注

即使对于大型“笨重的”StringBuilder 对象,使用 Chars[] 属性对一个或少量字符进行基于索引的访问几乎不影响性能;一般情况下,它是 0(n) 操作。 当迭代 StringBuilder 对象中的字符时,会对性能造成显著的影响,这是 O(n^2) 操作。

如果通过 StringBuilder 对象在使用基于字符的索引时遇到性能问题,可以使用以下任一解决方法:

  • 通过调用 ToString 方法,将 StringBuilder 实例转换为 String,然后访问字符串中的字符。

  • 将现有的 StringBuilder 对象的内容复制到新的预调整大小的 StringBuilder 对象。 由于新的 StringBuilder 对象并不笨重,因此可以提升性能。 例如:

    // 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)
    
  • 通过调用 StringBuilder(Int32) 构造函数,将 StringBuilder 对象的初始容量设置为约等于其最大预期大小的值。 请注意,即使 StringBuilder 很少达到其最大容量,它仍会分配整个内存块。

向 StringBuilder 对象添加文本

StringBuilder 类包括以下方法来扩展对象的内容 StringBuilder

  • Append方法追加字符串、子字符串、字符数组、字符数组的一部分、多次重复的单个字符或基元数据类型到对象的字符串表示形式 StringBuilder

  • AppendLine方法将行终止符或字符串及行结束符一起追加到 StringBuilder 对象。

  • AppendFormat方法将复合格式字符串追加到 StringBuilder 对象。 结果字符串中包含的对象的字符串表示形式可以反映当前系统区域性或指定区域性的格式设置约定。

  • Insert方法在对象中的指定位置插入字符串、子串、字符串的多个重复项、字符数组、部分字符数组或基元数据类型的字符串表示形式 StringBuilder 。 位置由从零开始的索引定义。

下面的示例使用 AppendAppendLineAppendFormatInsert 方法展开对象的文本 StringBuilder

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            <

从 StringBuilder 对象中删除文本

StringBuilder类包括可以减少的当前大小的方法StringBuilder实例。 Clear方法中删除所有字符,并设置Length属性设置为零。 Remove方法中删除指定的数量的特定索引位置开始的字符。 此外,从末尾删除字符StringBuilder对象通过设置其Length属性的值小于当前实例的长度。

下面的示例从对象中删除一些文本 StringBuilder 、显示其生成的容量、最大容量和 length 属性值,然后调用 Clear 方法从对象中删除所有字符 StringBuilder

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

修改 StringBuilder 对象中的文本

StringBuilder.Replace方法将替换整个 StringBuilder 对象或特定字符范围内出现的所有字符或字符串。 下面的示例使用 Replace 方法在对象中用问号 (? ) 来替换所有惊叹号 (! ) StringBuilder

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?

在 StringBuilder 对象中搜索文本

StringBuilder类不包括与 String.Contains 类提供的、和方法类似的方法 String.IndexOf String.StartsWith String ,这允许您在对象中搜索特定字符或子字符串。 若要确定子字符串的存在或起始字符位置,需要 String 使用字符串搜索方法或正则表达式方法搜索某个值。 可通过四种方式实现此类搜索,如下表所示。

方法 优点 缺点
搜索字符串值,然后将其添加到 StringBuilder 对象。 适用于确定子字符串是否存在。 子字符串的索引位置非常重要时,不能使用。
调用 ToString 并搜索返回的 String 对象。 如果将所有文本分配到 StringBuilder 对象,然后开始对其进行修改,则可轻松使用。 ToString如果您必须在将所有文本添加到对象之前进行修改,则重复调用会很繁琐 StringBuilder

如果要进行更改,则必须记得从对象的文本末尾进行操作 StringBuilder
使用 Chars[] 属性按顺序搜索字符范围。 如果您担心单个字符或小型子字符串,此方法非常有用。 如果搜索的字符数很大或者搜索逻辑很复杂,则这种情况很繁琐。

通过重复方法调用,导致非常大的对象性能非常差。
StringBuilder 对象转换为 String 对象,并对对象执行修改 String 如果修改次数较小,则此方法很有用。 如果修改的数量较大,则会使类的性能优势抵消 StringBuilder

让我们更详细地研究一下这些方法。

  • 如果搜索的目标是确定特定的子字符串是否存在 (也就是说,如果不感兴趣) 子字符串的位置,则可以在将字符串存储到对象之前对其进行搜索 StringBuilder 。 下面的示例提供了一个可能的实现。 它定义一个 StringBuilderFinder 类,该类的构造函数传递对对象的引用 StringBuilder 以及要在字符串中查找的子字符串。 在这种情况下,该示例将尝试确定是否已记录温度为华氏温度或摄氏温度,并将相应的引导文本添加到对象的开头 StringBuilder 。 随机数生成器用于选择以摄氏或华氏度为单位包含数据的数组。

    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
    
  • 调用 StringBuilder.ToString 方法将 StringBuilder 对象转换为 String 对象。 您可以使用或等方法搜索字符串 String.LastIndexOf String.StartsWith ,也可以使用正则表达式和 Regex 类搜索模式。 由于 StringBuilderString 对象使用 utf-16 编码存储字符,因此字符、子字符串和正则表达式匹配项的索引位置在这两个对象中是相同的。 这使您可以使用 StringBuilder 方法在对象中找到该文本的同一位置进行更改 String

    备注

    如果采用这种方法,应从对象的末尾开始工作, StringBuilder 这样就不必反复将 StringBuilder 对象转换为字符串。

    下面的示例阐释了这种方法。 它在对象中存储每个英文字母的四个匹配项 StringBuilder 。 然后,它将文本转换为 String 对象,并使用正则表达式标识每个四字符序列的起始位置。 最后,在除第一个序列外的每个四字符序列之前添加下划线,并将序列的第一个字符转换为大写。

    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
    
  • 使用 StringBuilder.Chars[] 属性可按顺序在对象中搜索一定范围内的字符 StringBuilder 。 如果要搜索的字符数很大或者搜索逻辑特别复杂,则这种方法可能不可行。 对于非常大的分块对象的基于字符索引的访问的性能影响 StringBuilder ,请参阅属性的文档 StringBuilder.Chars[]

    下面的示例与上一个示例的功能相同,但实现方式不同。 它使用 Chars[] 属性来检测某个字符值已更改的时间,在该位置插入一个下划线,并将新序列中的第一个字符转换为大写。

    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
    
  • 将所有未修改的文本存储在 StringBuilder 对象中,调用 StringBuilder.ToString 方法将对象转换 StringBuilderString 对象,然后对对象执行修改 String 。 如果只有少量的修改,可以使用此方法;否则,使用不可变字符串的成本可能会抵消使用对象的性能优势 StringBuilder

    下面的示例在功能上与前面两个示例相同,但实现方式不同。 它将创建一个 StringBuilder 对象,将其转换为 String 对象,然后使用正则表达式对该字符串执行所有剩余的修改。 Regex.Replace(String, String, MatchEvaluator)方法使用 lambda 表达式对每个匹配项执行替换。

    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
    

将 StringBuilder 对象转换为字符串

必须先将 StringBuilder 对象转换为 String 对象,然后才能将 StringBuilder 对象表示的字符串传递给包含 String 参数的方法,或在用户界面中显示它。 可以通过调用方法来执行此转换 StringBuilder.ToString 。 有关说明,请参阅前面的示例,该示例调用 ToString 方法将对象转换 StringBuilder 为字符串,以便可以将其传递给正则表达式方法。

调用方说明

在 .net Core 和 .NET Framework 4.0 及更高版本中,当你 StringBuilder 通过调用构造函数实例化对象时, StringBuilder(Int32, Int32) 实例的长度和容量 StringBuilder 可能会超出其属性的值 MaxCapacity 。 当调用 Append(String)AppendFormat(String, Object) 方法追加小字符串时,尤其如此。

构造函数

StringBuilder()

初始化 StringBuilder 类的新实例。

StringBuilder(Int32)

使用指定的容量初始化 StringBuilder 类的新实例。

StringBuilder(Int32, Int32)

初始化 StringBuilder 类的新实例,该类起始于指定容量并且可增长到指定的最大容量。

StringBuilder(String)

使用指定的字符串初始化 StringBuilder 类的新实例。

StringBuilder(String, Int32)

使用指定的字符串和容量初始化 StringBuilder 类的新实例。

StringBuilder(String, Int32, Int32, Int32)

从指定的子字符串和容量初始化 StringBuilder 类的新实例。

属性

Capacity

获取或设置可包含在当前实例所分配的内存中的最大字符数。

Chars[Int32]

获取或设置此实例中指定字符位置处的字符。

Length

获取或设置当前 StringBuilder 对象的长度。

MaxCapacity

获取此实例的最大容量。

方法

Append(Boolean)

向此实例追加指定的布尔值的字符串表示形式。

Append(Byte)

向此实例追加指定的 8 位无符号整数的字符串表示形式。

Append(Char)

将指定的 Char 对象的字符串表示形式追加到此实例。

Append(Char*, Int32)

将从指定地址开始的 Unicode 字符数组追加到此实例。

Append(Char, Int32)

向此实例追加 Unicode 字符的字符串表示形式指定数目的副本。

Append(Char[])

向此实例追加指定数组中的 Unicode 字符的字符串表示形式。

Append(Char[], Int32, Int32)

向此实例追加指定的 Unicode 字符子数组的字符串表示形式。

Append(Decimal)

向此实例追加指定的十进制数的字符串表示形式。

Append(Double)

向此实例追加指定的双精度浮点数的字符串表示形式。

Append(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

使用指定的格式向此实例追加指定的内插字符串。

Append(Int16)

向此实例追加指定的 16 位有符号整数的字符串表示形式。

Append(Int32)

向此实例追加指定的 32 位有符号整数的字符串表示形式。

Append(Int64)

向此实例追加指定的 64 位有符号整数的字符串表示形式。

Append(Object)

向此实例追加指定对象的字符串表示形式。

Append(ReadOnlyMemory<Char>)

向此实例追加指定的只读字符内存区域的字符串表示形式。

Append(ReadOnlySpan<Char>)

向此实例追加指定的只读字符范围的字符串表示形式。

Append(SByte)

向此实例追加指定的 8 位有符号整数的字符串表示形式。

Append(Single)

向此实例追加指定的单精度浮点数的字符串表示形式。

Append(String)

向此实例追加指定字符串的副本。

Append(String, Int32, Int32)

向此实例追加指定子字符串的副本。

Append(StringBuilder)

向此实例追加指定的字符串生成器的字符串表示形式。

Append(StringBuilder, Int32, Int32)

向此实例追加指定字符串生成器中的子字符串副本。

Append(StringBuilder+AppendInterpolatedStringHandler)

将指定的内插字符串追加到此实例。

Append(UInt16)

向此实例追加指定的 16 位无符号整数的字符串表示形式。

Append(UInt32)

向此实例追加指定的 32 位无符号整数的字符串表示形式。

Append(UInt64)

向此实例追加指定的 64 位无符号整数的字符串表示形式。

AppendFormat(IFormatProvider, String, Object)

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都使用指定的格式提供程序替换为单个参数的字符串表示形式。

AppendFormat(IFormatProvider, String, Object, Object)

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都使用指定的格式提供程序替换为两个参数中任一个的字符串表示形式。

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

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都使用指定的格式提供程序替换为三个参数中任一个的字符串表示形式。

AppendFormat(IFormatProvider, String, Object[])

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都使用指定的格式提供程序由参数数组中相应参数的字符串表示形式替换。

AppendFormat(String, Object)

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为一个自变量的字符串表示形式。

AppendFormat(String, Object, Object)

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为这两个参数中任意一个参数的字符串表示形式。

AppendFormat(String, Object, Object, Object)

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为这三个参数中任意一个参数的字符串表示形式。

AppendFormat(String, Object[])

向此实例追加通过处理复合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都由参数数组中相应参数的字符串表示形式替换。

AppendJoin(Char, Object[])

使用各成员之间指定的字符分隔符连接所提供的对象数组中的元素的字符串表示形式,然后将结果附加到字符串生成器的当前实例。

AppendJoin(Char, String[])

使用各字符串之间指定的字符分隔符连接所提供的数组的字符串,然后将结果附加到字符串生成器的当前实例。

AppendJoin(String, Object[])

使用各成员之间指定的分隔符连接所提供的对象数组中的元素的字符串表示形式,然后将结果附加到字符串生成器的当前实例。

AppendJoin(String, String[])

使用各字符串之间指定的分隔符连接所提供的数组的字符串,然后将结果附加到字符串生成器的当前实例。

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

使用各成员之间指定的字符分隔符连接和附加集合的成员。

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

使用各成员之间指定的分隔符连接和附加集合的成员。

AppendLine()

将默认的行终止符追加到当前 StringBuilder 对象的末尾。

AppendLine(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)

使用指定的格式(后跟默认的行终止符)将指定的内插字符串追加到当前 StringBuilder 对象的末尾。

AppendLine(String)

将后面跟有默认行终止符的指定字符串的副本追加到当前 StringBuilder 对象的末尾。

AppendLine(StringBuilder+AppendInterpolatedStringHandler)

在当前 StringBuilder 对象的末尾追加指定的内插字符串,后跟默认的行终止符。

Clear()

从当前 StringBuilder 实例中移除所有字符。

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

将此实例的指定段中的字符复制到目标 Char 数组的指定段中。

CopyTo(Int32, Span<Char>, Int32)

将此实例的指定段中的字符复制到目标 Char 范围。

EnsureCapacity(Int32)

确保 StringBuilder 的此实例的容量至少是指定值。

Equals(Object)

确定指定对象是否等于当前对象。

(继承自 Object)
Equals(ReadOnlySpan<Char>)

返回一个值,该值指示此实例中的字符是否等于指定的只读字符范围中的字符。

Equals(StringBuilder)

返回一个值,该值指示此实例是否等于指定的对象。

GetChunks()

返回一个对象,该对象可用于循环访问从此 StringBuilder 实例创建的 ReadOnlyMemory<Char> 中表示的字符区块。

GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetType()

获取当前实例的 Type

(继承自 Object)
Insert(Int32, Boolean)

将布尔值的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Byte)

将指定的 8 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Char)

将指定的 Unicode 字符的字符串表示形式插入到此实例中的指定位置。

Insert(Int32, Char[])

将指定的 Unicode 字符数组的字符串表示形式插入到此实例中的指定字符位置。

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

将指定的 Unicode 字符子数组的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Decimal)

将十进制数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Double)

将双精度浮点数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Int16)

将指定的 16 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Int32)

将指定的 32 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Int64)

将 64 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Object)

将对象的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, ReadOnlySpan<Char>)

将字符序列插入到此实例中的指定字符位置。

Insert(Int32, SByte)

将指定的 8 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, Single)

将单精度浮点数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, String)

将字符串插入到此实例中的指定字符位置。

Insert(Int32, String, Int32)

将指定字符串的一个或更多副本插入到此实例中的指定字符位置。

Insert(Int32, UInt16)

将 16 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, UInt32)

将 32 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。

Insert(Int32, UInt64)

将 64 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。

MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
Remove(Int32, Int32)

将指定范围的字符从此实例中移除。

Replace(Char, Char)

将此实例中出现的所有指定字符替换为其他指定字符。

Replace(Char, Char, Int32, Int32)

将此实例的子字符串中出现的所有指定字符替换为其他指定字符。

Replace(String, String)

将此实例中出现的所有指定字符串的替换为其他指定字符串。

Replace(String, String, Int32, Int32)

将此实例的子字符串中出现的所有指定字符串替换为其他指定字符串。

ToString()

将此实例的值转换为 String

ToString(Int32, Int32)

将此实例中子字符串的值转换为 String

显式接口实现

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

使用所需的数据填充 SerializationInfo 对象来反序列化当前 StringBuilder 对象。

适用于

另请参阅