导出 (0) 打印
全部展开
此文章由机器翻译。 将光标移到文章的句子上,以查看原文。 更多信息。
译文
原文

StringBuilder 类

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

System.Object
  System.Text.StringBuilder

命名空间:  System.Text
程序集:  mscorlib(在 mscorlib.dll 中)

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

StringBuilder 类型公开以下成员。

  名称说明
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder()初始化 StringBuilder 类的新实例。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder(Int32)使用指定的容量初始化 StringBuilder 类的新实例。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder(String)使用指定的字符串初始化 StringBuilder 类的新实例。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder(Int32, Int32)初始化 StringBuilder 类的新实例,该类起始于指定容量并且可增长到指定的最大容量。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder(String, Int32)使用指定的字符串和容量初始化 StringBuilder 类的新实例。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持StringBuilder(String, Int32, Int32, Int32)用指定的子字符串和容量初始化 StringBuilder 类的新实例。
页首

  名称说明
公共属性由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Capacity获取或设置可包含在当前实例所分配的内存中的最大字符数。
公共属性由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Chars获取或设置此实例中指定字符位置处的字符。
公共属性由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Length获取或设置当前 StringBuilder 对象的长度。
公共属性受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持MaxCapacity获取此实例的最大容量。
页首

  名称说明
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Boolean)在此实例追加指定的布尔值的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Byte)在此实例追加指定的 8 位无符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Char)在此实例追加指定 Unicode 字符的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Char[])在此实例追加指定数组中的 Unicode 字符的字符串表示形式。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Decimal)在此实例追加指定的十进制数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Double)在此实例追加指定的双精度浮点数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Int16)在此实例追加指定的 16 位有符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Int32)在此实例追加指定的 32 位有符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Int64)在此实例追加指定的 64 位有符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Object)在此实例追加指定对象的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(SByte)在此实例追加指定的 8 位有符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Single)在此实例追加指定的单精度浮点数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(String)在此实例追加指定字符串的副本。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(UInt16)在此实例追加指定的 16 位无符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(UInt32)在此实例追加指定的 32 位无符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(UInt64)在此实例追加指定的 64 位无符号整数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Char, Int32)在此实例追加 Unicode 字符的字符串表示形式指定数目的副本。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(Char[], Int32, Int32)在此实例追加指定的 Unicode 字符子数组的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Append(String, Int32, Int32)在此实例追加指定子字符串的副本。
公共方法AppendFormat(String, Object)向此实例追加通过处理组合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为一个参数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AppendFormat(String, Object[])向此实例追加通过处理组合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都由参数数组中相应参数的字符串表示形式替换。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AppendFormat(IFormatProvider, String, Object[])向此实例追加通过处理组合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都使用指定的格式提供程序由参数数组中相应参数的字符串表示形式替换。
公共方法AppendFormat(String, Object, Object)向此实例追加通过处理组合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为这两个参数中任意一个参数的字符串表示形式。
公共方法AppendFormat(String, Object, Object, Object)向此实例追加通过处理组合格式字符串(包含零个或更多格式项)而返回的字符串。 每个格式项都替换为这三个参数中任意一个参数的字符串表示形式。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AppendLine()将默认的行终止符追加到当前 StringBuilder 对象的末尾。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持AppendLine(String)将后面跟有默认行终止符的指定字符串的副本追加到当前 StringBuilder 对象的末尾。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Clear从当前 StringBuilder 实例中移除所有字符。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持CopyTo将此实例的指定段中的字符复制到目标 Char 数组的指定段中。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持EnsureCapacity确保 StringBuilder 的此实例的容量至少是指定值。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(Object)确定指定的对象是否等于当前对象。 (继承自 Object。)
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Equals(StringBuilder)返回一个值,该值指示此实例是否等于指定的对象。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持GetHashCode作为默认哈希函数。 (继承自 Object。)
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持GetType获取当前实例的 Type (继承自 Object。)
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Boolean)将布尔值的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Byte)将指定的 8 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Char)将指定的 Unicode 字符的字符串表示形式插入到此实例中的指定位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Char[])将指定的 Unicode 字符数组的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Decimal)将十进制数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Double)将双精度浮点数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Int16)将指定的 16 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Int32)将指定的 32 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Int64)将 64 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Object)将对象的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, SByte)将指定的 8 位带符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Single)将单精度浮点数的字符串表示形式插入到此实例中的指定字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, String)将字符串插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, UInt16)将 16 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, UInt32)将 32 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, UInt64)将 64 位无符号整数的字符串表示形式插入到此实例中的指定字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, String, Int32)将指定字符串的一个或更多副本插入到此实例中的指定字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Insert(Int32, Char[], Int32, Int32)将指定的 Unicode 字符子数组的字符串表示形式插入到此实例中的指定字符位置。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Remove将指定范围的字符从此实例中移除。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(Char, Char)将此实例中所有的指定字符替换为其他指定字符。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(String, String)将此实例中所有指定字符串的匹配项替换为其他指定字符串。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(Char, Char, Int32, Int32)将此实例的子字符串中所有指定字符的匹配项替换为其他指定字符。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持Replace(String, String, Int32, Int32)将此实例的子字符串中所有指定字符串的匹配项替换为其他指定字符串。
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToString()将此实例的值转换为 String (重写 Object.ToString()。)
公共方法由 XNA Framework 提供支持受 可移植类库 支持受 适用于 Windows 应用商店应用的 .NET 支持ToString(Int32, Int32)将此实例中子字符串的值转换为 String
页首

  名称说明
显式接口实现私有方法ISerializable.GetObjectData基础结构。用反序列化当前 StringBuilder 对象所需的数据填充 System.Runtime.Serialization.SerializationInfo 对象。
页首

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

本节内容:

字符串和 StringBuilder的类型

虽然 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 对象维护缓冲区容纳扩展到该字符串。 如果有足够的空间,新数据将被追加到缓冲区;否则,将分配一个新的、更大的缓冲区,原始缓冲区中的数据被复制到新的缓冲区,然后将新数据追加到新的缓冲区。

重要说明重要事项

虽然 StringBuilder 选件类比 String 选件类通常提供更好的性能,当不应使用 StringBuilder 自动替换 String 时,就要操作字符串。 性能取决于该字符串的大小,对新的字符串将分配的内存量,您的系统 app 的执行和操作的类型。 您应准备测试您的应用程序确定 StringBuilder 实际上是否可显着提高性能。

在这些条件下考虑使用 String 选件类:

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

  • 当执行串联运算的内置的数字,尤其是对于字符串文本。 在这种情况下,编译器可能将串联运算到单个操作。

  • 当您生成字符串时,当您必须执行广泛的搜索操作。 StringBuilder 选件类没有搜索方法 ,如 IndexOfStartsWith 您必须转换为 StringStringBuilder 对象这些操作的,这样,可以对从使用 StringBuilder的性能。 有关详细信息,请参阅 搜索在 StringBuilder 对象的文本 部分。

在这些条件下考虑使用 StringBuilder 选件类:

  • 当您希望您的应用程序创建一个未知的设置为字符串的更改在设计时 (例如,当您使用循环连接包含用户输入的随机数字符串)。

  • 当您希望您的应用程序创建一个大量为字符串的更改。

StringBuilder 工作原理

StringBuilder.Length 属性指示 StringBuilder 对象当前包含的字符数。 如果添加字符到StringBuilder 对象,其长度增加,直到达到其等同于 StringBuilder.Capacity 属性的大小,定义字符数对象可以包含的大小。 如果添加的字符数导致 StringBuilder 对象的长度超过其当前容量,分配新的内存,Capacity 属性的值在全球,新字符添加到 StringBuilder 对象,调整其 Length 属性。 动态分配 StringBuilder 对象的附加内存,直到其达到 StringBuilder.MaxCapacity 属性定义的值。 当最大容量时,进一步内存不可用于 StringBuilder 对象分配,并且,尝试添加字符或扩展在其最大容量之外引发 ArgumentOutOfRangeExceptionOutOfMemoryException 异常。

下面的示例演示如何 StringBuilder 对象分配新的内存和动态增加其容量,该字符串分配给对象展开。 代码通过调用其默认值 (无参数) 构造函数创建一 StringBuilder 对象。 此对象默认值容量为 16 个字符,因此,其最大容量大于 20 亿个字符。 追加该字符串“this is sentence.”在新的内存分配的结果,因为字符串的长度 (19 个字符) 超过 StringBuilder 对象的默认值容量。 对象的容量加倍为 32 个字符,新的字符串添加,对象的长度现在等于 19 个字符。 代码随后追加该字符串“this is an additional sentence.”为 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 对象的初始容量:

  • 当您创建对象,通过调用包括一个 capacity 参数的任何一个 StringBuilder 构造函数。

  • 通过显式分配新值到StringBuilder.Capacity 特性扩展现有 StringBuilder 对象。 请注意属性与 StringBuilder 对象的最大容量引发异常,则新的容量大于现有的容量小于或大于。

  • 通过调用使用新的容量的 StringBuilder.EnsureCapacity 方法。 新的容量必须不大于 StringBuilder 对象的最大容量。 但是,与到 Capacity 属性的赋值,EnsureCapacity 不引发异常,如果希望新的容量大于现有的容量小于;在这种情况下,方法调用不起作用。

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

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

如前一节所示,只要现有的容量是不够用的,则附加内存分配一节所示,并 StringBuilder 对象二进制文件的容量到值的由 MaxCapacity 属性定义。

通常,默认值容量和最大容量对于大多数 apps 足够的。 您可能会考虑设置这些值在下面的情况:

  • 如果 StringBuilder 对象的最终可能增加到最大,通常超过几 MB。 在这种情况下,都是设置初始 Capacity 属性的某个具有性能优势到一个显着最大值从而无需进行大量内存重新发布的需要。

  • 如果您的应用程序在具有有限内存的系统运行。 在这种情况下,除了 Int32.MaxValue 可能要考虑设置 MaxCapacity 属性,如果您的应用程序处理在一个内存约束的环境中都可使执行的大字符串。

实例化 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或 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的实例返回一个引用到同一个实例。 这使您可以调用 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.
    
    
    
  • 可以在单个语句中执行一系列调用方法。 如果想要编写将连续操作依次连接起来的单个语句,这将很方便。 下面的例子中整合来自前面的例子3方法调用到一个单一的代码行。

    
    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 对象的字符。

y9sxk6fy.collapse_all(zh-cn,VS.110).gif重复 StringBuilder 字符

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

下面的示例演示了 Chars 属性。 它将追加十个随机数到 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


y9sxk6fy.collapse_all(zh-cn,VS.110).gif将文本添加到 StringBuilder 对象

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            <


y9sxk6fy.collapse_all(zh-cn,VS.110).gif删除文本从 StringBuilder 对象

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


y9sxk6fy.collapse_all(zh-cn,VS.110).gif在修改 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?


在查找 StringBuilder 对象的文本

StringBuilder 选件类包括方法类似于 String.ContainsString.IndexOfString 提供的方法 String.StartsWith 类,允许您搜索对象特定字符或子字符串。 确定子字符串的存在或开始字符位置需要使用字符串搜索方法或正则表达式方法,则搜索一个 String 值。 如下表所示,有四种方法可以实现此类搜索。

方法

优点

Cons

在添加之前的搜索字符串值转换为 StringBuilder 对象。

对确定子字符串是否存在有用处。

不能使用在子字符串的索引位置这点很重要。

调用 ToString 并搜索返回的 String 对象。

这是很容易使用的,如果将所有文本为StringBuilder 对象,然后开始修改它。

样式重复调用 ToString,如果必须进行修改,在任何文本添加到 StringBuilder 对象。

如果进行了更改,则必须确保从末尾的 StringBuilder 对象的文本工作。

使用 Chars 属性顺序搜索字符范围。

如果牵涉到单独的字符或一个小的子字符串是有用的。

如果搜索的字符数大或者搜索逻辑很复杂将是难处理的。

转换为 String 对象的 StringBuilder 对象,并对 String 对象的修改。

如果修改的数目很小这是有用的。

如果修改的数目很大,StringBuilder 选件类的性能将没用。

我们将更详细地说明这些技术。

  • 如果搜索的目标是确定一个特定子字符串是否存在 (即,如果您不需要该子字符串的位置感兴趣),在存储它们之前,可以在 StringBuilder 对象搜索字符串。 下面的示例提供了一种可能的实现。 它定义构造函数传递给查找的 StringBuilder 对象和该子字符串的一对该字符串的 StringBuilderFinder 选件类。 在这种情况下,该示例尝试确定记录温度是否在华氏度或摄氏温度,并添加适当的显示文本。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 方法转换为 String 对象的 StringBuilder 对象。 通过使用之类的方法 String.LastIndexOfString.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
    
    
    
  • 使用 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 方法转换为 String 对象的 StringBuilder 对象,并对 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 对象表示的字符串传递给具有 String 参数的方法并在用户界面中显示它。 可通过调用 StringBuilder.ToString 方法来执行此转换。 有关说明,请参见前面的示例中,调用 ToString 方法转换为字符串的一 StringBuilder 对象,以便可以传递给正则表达式方法。

对调用者的说明

在 .NET Framework 4 和 .NET Framework 4.5,当您通过调用 StringBuilder(Int32, Int32) 构造函数实例化 StringBuilder 对象时,长度和 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


.NET Framework

受以下版本支持:4.5.2、4.5.1、4.5、4、3.5、3.0、2.0、1.1、1.0

.NET Framework Client Profile

受以下版本支持:4、3.5 SP1

可移植类库

受以下版本支持:可移植类库

适用于 Windows 应用商店应用的 .NET

受以下版本支持:Windows 8

适用于 Windows Phone 应用的 .NET

受以下版本支持:Windows Phone 8、Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008(不支持服务器核心角色), Windows Server 2008 R2(支持带 SP1 或更高版本的服务器核心角色;不支持 Itanium)

.NET Framework 并不是对每个平台的所有版本都提供支持。有关支持的版本的列表,请参阅.NET Framework 系统要求

此类型的任何公共 static(在 Visual Basic 中为 Shared) 成员都是线程安全的。但不保证所有实例成员都是线程安全的。

社区附加资源

添加
显示:
© 2014 Microsoft