本文由机器翻译。若要查看英语原文,请勾选“英语”复选框。 也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

StringBuilder 类

 

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

若要浏览此类型的.NET Framework 源代码,请参阅 Reference Source

命名空间:   System.Text
程序集:  mscorlib(位于 mscorlib.dll)

System.Object
  System.Text.StringBuilder

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class StringBuilder : ISerializable

名称说明
System_CAPS_pubmethodStringBuilder()

初始化 StringBuilder 类的新实例。

System_CAPS_pubmethodStringBuilder(Int32)

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

System_CAPS_pubmethodStringBuilder(Int32, Int32)

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

System_CAPS_pubmethodStringBuilder(String)

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

System_CAPS_pubmethodStringBuilder(String, Int32)

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

System_CAPS_pubmethodStringBuilder(String, Int32, Int32, Int32)

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

名称说明
System_CAPS_pubpropertyCapacity

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

System_CAPS_pubpropertyChars[Int32]

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

System_CAPS_pubpropertyLength

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

System_CAPS_pubpropertyMaxCapacity

获取此实例的最大容量。

名称说明
System_CAPS_pubmethodAppend(Boolean)

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

System_CAPS_pubmethodAppend(Byte)

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

System_CAPS_pubmethodAppend(Char)

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

System_CAPS_pubmethodAppend(Char*, Int32)

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

System_CAPS_pubmethodAppend(Char, Int32)

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

System_CAPS_pubmethodAppend(Char[])

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

System_CAPS_pubmethodAppend(Char[], Int32, Int32)

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

System_CAPS_pubmethodAppend(Decimal)

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

System_CAPS_pubmethodAppend(Double)

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

System_CAPS_pubmethodAppend(Int16)

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

System_CAPS_pubmethodAppend(Int32)

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

System_CAPS_pubmethodAppend(Int64)

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

System_CAPS_pubmethodAppend(Object)

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

System_CAPS_pubmethodAppend(SByte)

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

System_CAPS_pubmethodAppend(Single)

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

System_CAPS_pubmethodAppend(String)

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

System_CAPS_pubmethodAppend(String, Int32, Int32)

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

System_CAPS_pubmethodAppend(UInt16)

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

System_CAPS_pubmethodAppend(UInt32)

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

System_CAPS_pubmethodAppend(UInt64)

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

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object)

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

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object, Object)

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

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object, Object, Object)

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

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object[])

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

System_CAPS_pubmethodAppendFormat(String, Object)

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

System_CAPS_pubmethodAppendFormat(String, Object, Object)

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

System_CAPS_pubmethodAppendFormat(String, Object, Object, Object)

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

System_CAPS_pubmethodAppendFormat(String, Object[])

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

System_CAPS_pubmethodAppendLine()

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

System_CAPS_pubmethodAppendLine(String)

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

System_CAPS_pubmethodClear()

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

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

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

System_CAPS_pubmethodEnsureCapacity(Int32)

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

System_CAPS_pubmethodEquals(Object)

确定指定的对象是否等于当前对象。(继承自 Object。)

System_CAPS_pubmethodEquals(StringBuilder)

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

System_CAPS_pubmethodGetHashCode()

作为默认哈希函数。(继承自 Object。)

System_CAPS_pubmethodGetType()

获取当前实例的 Type(继承自 Object。)

System_CAPS_pubmethodInsert(Int32, Boolean)

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

System_CAPS_pubmethodInsert(Int32, Byte)

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

System_CAPS_pubmethodInsert(Int32, Char)

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

System_CAPS_pubmethodInsert(Int32, Char[])

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

System_CAPS_pubmethodInsert(Int32, Char[], Int32, Int32)

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

System_CAPS_pubmethodInsert(Int32, Decimal)

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

System_CAPS_pubmethodInsert(Int32, Double)

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

System_CAPS_pubmethodInsert(Int32, Int16)

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

System_CAPS_pubmethodInsert(Int32, Int32)

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

System_CAPS_pubmethodInsert(Int32, Int64)

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

System_CAPS_pubmethodInsert(Int32, Object)

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

System_CAPS_pubmethodInsert(Int32, SByte)

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

System_CAPS_pubmethodInsert(Int32, Single)

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

System_CAPS_pubmethodInsert(Int32, String)

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

System_CAPS_pubmethodInsert(Int32, String, Int32)

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

System_CAPS_pubmethodInsert(Int32, UInt16)

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

System_CAPS_pubmethodInsert(Int32, UInt32)

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

System_CAPS_pubmethodInsert(Int32, UInt64)

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

System_CAPS_pubmethodRemove(Int32, Int32)

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

System_CAPS_pubmethodReplace(Char, Char)

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

System_CAPS_pubmethodReplace(Char, Char, Int32, Int32)

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

System_CAPS_pubmethodReplace(String, String)

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

System_CAPS_pubmethodReplace(String, String, Int32, Int32)

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

System_CAPS_pubmethodToString()

将此实例的值转换为 String(覆盖 Object.ToString()。)

System_CAPS_pubmethodToString(Int32, Int32)

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

名称说明
System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

此 API 支持 产品 基础结构,不应从代码直接使用。 使用所需的数据填充 System.Runtime.Serialization.SerializationInfo 对象来反序列化当前 StringBuilder 对象。

System_CAPS_note说明

若要查看此类型的.NET Framework 源代码,请参阅 Reference Source 您可以浏览源代码、 下载脱机查看参考资料和调试; 在逐句通过源 (包括修补程序和更新)see instructions.

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

本节内容:

尽管 StringBuilderString 二者都表示序列的字符,它们的实现方式有所不同。 String 是一个不可变的类型。 也就是说,它看起来可以修改每个操作 String 对象实际上会创建一个新字符串。

例如,对调用 String.Concat 方法在下面的 C# 示例显示一个名为的字符串变量的值更改 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 对象会维护一个缓冲区来容纳扩展到字符串。 如果没有可用; 空间,将新数据追加到缓冲区否则为系统会分配新的、 更大的缓冲区、 从原始缓冲区的数据复制到新的缓冲区和新的数据则追加到新的缓冲区。

System_CAPS_important重要事项

尽管 StringBuilder 类通常提供更好的性能比 String 类中,您应该不会自动替换 StringStringBuilder 每当你想要操作的字符串。 性能取决于字符串,要为新的字符串、 在其执行您的应用程序,系统和操作的类型的分配的内存量的大小。 您应该准备好测试您的应用程序,以确定是否 StringBuilder 实际上提供了显著改进的性能。

请考虑使用 String 在这些情况下的类︰

  • 当您的应用程序将对字符串进行的更改的数量很小。 在这些情况下, StringBuilder 可能可以忽略不计的提议或不会改善性能通过 String

  • 当您正在执行固定的数量的串联运算,特别是对于字符串文字。 在这种情况下,编译器可能将合并到单个操作串联运算。

  • 当需要时您正在构建您的字符串执行广泛的搜索操作。 StringBuilder 类缺少搜索方法如 IndexOfStartsWith 您必须转换 StringBuilder 对象传递给 String 为这些操作,这会让使用的性能优势 StringBuilder 有关详细信息,请参阅 StringBuilder 对象中搜索的文本 部分。

请考虑使用 StringBuilder 在这些情况下的类︰

  • 当您希望您的应用程序在设计时 (例如,在使用一个循环来连接字符串,其中包含用户输入次数随机时) 对字符串进行的更改数未知。

  • 当您希望您的应用程序对字符串进行大量更改。

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

下面的示例演示如何 StringBuilder 对象分配新内存,并动态地增加其容量限制,随着分配给该对象的字符串的扩展。 该代码将创建 StringBuilder 通过调用其默认 (无参数) 构造函数的对象。 此对象的默认容量是 16 个字符,其最大容量为 20 亿多个字符。 将字符串附加"这一个句子"。 因为 (19 个字符) 的字符串长度超过了默认的容量的会导致新的内存分配 StringBuilder 对象。 该对象的容量加倍为 32 个字符、 添加新的字符串,并且对象的长度现在等于 19 个字符。 该代码然后追加的字符串"This is 其他句子"。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

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

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

  • 通过调用任一 StringBuilder 构造函数,其中包含 capacity 参数创建对象时。

  • 通过显式分配新值赋给 StringBuilder.Capacity 要扩展的现有属性 StringBuilder 对象。 请注意,属性将引发异常,新的容量是否小于现有容量或大于 StringBuilder 对象的最大容量。

  • 通过调用 StringBuilder.EnsureCapacity 新的容量的方法。 新的容量不能晚于 StringBuilder 对象的最大容量。 但是,与分配给不同 Capacity 属性, EnsureCapacity 时不引发异常所需的新容量小于现有容量; 在这种情况下,该方法调用不起作用。

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

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

如上一节所示,只要现有容量不足、 其他内存分配和容量的 StringBuilder 对象定义的值由双精度型值 MaxCapacity 属性。

一般情况下,默认的容量和最大容量就足够了对于大多数应用程序。 你可以考虑在以下情况下的这些值进行设置︰

  • 如果最终大小 StringBuilder 对象很可能会变得非常大,通常超出几兆字节。 在这种情况下,可能有从设置初始某些性能优势 Capacity 属性的太多的值,以消除过多内存重新分配的需要。

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

您实例化 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 或 value Length, 两者中较大

Int32.MaxValue

StringBuilder(String, Int32)

通过定义 value 参数

通过定义 capacity 参数或 value Length, 两者中较大。

Int32.MaxValue

StringBuilder(String, Int32, Int32, Int32)

通过定义 value Substring(startIndex, length)

通过定义 capacity 参数或 value Length, 两者中较大。

通过定义 maxCapacity 参数

下面的示例使用三个这些构造函数重载来实例化 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

在修改字符串的方法的大多数 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.
    
  • 可以在单个语句来进行一系列方法调用。 这可能是如果您想要编写一个语句所链接的连续的操作非常方便。 下面的示例将上一示例中的三个方法调用合并为一行代码。

    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.
    

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

您可以访问中的字符 StringBuilder 对象使用 StringBuilder.Chars 属性。 在 C# 中, Chars 是一个索引器; 在 Visual Basic 中,它是默认属性的 StringBuilder 类。 这使您可以设置或检索每个字符使用它们的索引,而无需显式引用 Chars 属性。 中字符的 StringBuilder 对象在索引为 0 (零) 处开始并继续进行索引 Length -1。

下面的示例阐释 Chars 属性。 将追加到十个随机数 StringBuilder 对象,并会接着循环的每个字符。 如果该字符的 Unicode 类别为 UnicodeCategory.DecimalDigitNumber, ,它按 1 递减数 (或数更改为 9,如果其值为 0)。 该示例显示的内容 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

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

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

  • AppendLine 方法将行终止符或行终止符写入沿的字符串追加 StringBuilder 对象。

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

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

下面的示例使用 Append, ,AppendLine, ,AppendFormat, ,和 Insert 方法以展开的文本 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            <

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

下面的示例删除了一些来自文本 StringBuilder 对象,显示其生成的容量、 最大容量和长度属性值,然后调用 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

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?

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
    
  • 调用 StringBuilder.ToString 方法将转换 StringBuilder 对象传递给 String 对象。 您可以通过使用以下方法搜索字符串 String.LastIndexOfString.StartsWith, ,也可以使用正则表达式和 Regex 类来搜索模式。 因为这两 StringBuilderString 对象使用 utf-16 编码以存储子字符串的字符的索引位置的字符和正则表达式匹配项都在这两个对象相同。 这使您可以使用 StringBuilder 方法,以便可以在同一位置中找到该文本更改 String 对象。

    System_CAPS_note说明

    如果您采用这种方法,则应处理从结尾处 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
    
  • 使用 StringBuilder.Chars 属性来按顺序搜索中的字符范围 StringBuilder 对象。 如果要在其中搜索的字符数大,或搜索逻辑是特别复杂,这种方法可能不可行。

    下面的示例在功能上与前面的示例相同,但在实现中不同。 它使用 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
    
  • 存储中的所有未修改的文本 StringBuilder 对象,请调用 StringBuilder.ToString 方法将转换 StringBuilder 对象传递给 String 对象,并执行所做的修改 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
    

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

调用函数说明:

在.NET Framework 4 和 .NET Framework 4.5, ,当您实例化 StringBuilder 对象通过调用 StringBuilder(Int32, Int32) 构造函数的长度和容量的 StringBuilder 实例可以增长到的值超过其 MaxCapacity 属性。 发生这种情况尤其是当您调用 AppendAppendFormat 追加小型字符串的方法。

下面的示例演示如何调用许多由定义的方法 StringBuilder 类。

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

通用 Windows 平台
自 8 起可用
.NET Framework
自 1.1 起可用
可移植类库
可移植 .NET 平台 中受支持
Silverlight
自 2.0 起可用
Windows Phone Silverlight
自 7.0 起可用
Windows Phone
自 8.1 起可用

此类型的所有公共静态(Visual Basic 中的 已共享 在 Visual Basic 中)成员都是线程安全的。不保证所有实例成员都是线程安全的。

返回页首
显示: