探究 .NET 源码系列：System.Text.StringBuilder
[.NET source] StringBuilder
| namespace | System.Text.StringBuilder |
|---|---|
| project | ndp.csproj |
| file | stringbuilder.cs |
| version | 属于 .net standard 2.0 的 .NET Framework 4.8 |
摘要
This class represents a mutable string. It is convenient for situations in which it is desirable to modify a string, perhaps by removing, replacing, or inserting characters, without creating a new String subsequent to each modification.
此类型代表一个可变字符串，有时我们需要对字符串进行移除，替换，插入字符等操作，但又不想每个操作都产生一个新的子串，在这样的情境下 StringBuilder 就特别有用。
A StringBuilder is internally represented as a linked list of blocks each of which holds a chunk of the string. It turns out string as a whole can also be represented as just a chunk, so that is what we do.
StringBuilder 在内部表示为由块（Block）组成的链表，每个块都包含一个字符串块（Chunk）。 实际上完整的字符串也可以仅用一个块来表示，所以我们便这么实现了。
public sealed class StringBuilder : ISerializable {
// The characters in this block
internal char[] m_ChunkChars;
// Link to the block logically before this block
internal StringBuilder m_ChunkPrevious;
// The index in m_ChunkChars that represent the end of the block
internal int m_ChunkLength;
// The logial offset (sum of all characters in previous blocks)
internal int m_ChunkOffset;
internal int m_MaxCapacity = 0;
internal const int DefaultCapacity = 16;
// ...
// We want to keep chunk arrays out of large object heap (< 85K bytes ~ 40K chars) to be sure.
// Making the maximum chunk size big means less allocation code called, but also more waste
// in unused characters and slower inserts / replaces (since you do need to slide characters over
// within a buffer).
internal const int MaxChunkSize = 8000;
// ...
}部分类型成员说明：
- m_ChunkChars：内建字符数组，存储字符串内容用
- m_ChunkLength：指向了当前 chunk 中的字符数组 m_ChunkChars 的最后一个有效字符，即当前 chunk 有效内容的长度
- m_ChunkOffset：之前所有 blocks / chunks 的字符总数，即当前 chunk 的字符偏移量
- m_MaxCapacity：完整字符串的长度限制
从 StringBuilder 的类型成员能够推断出，实际上每个 StringBuilder 都被看作是一个 Chunk，在不断添加新的字符串内容时，当前创建的 StringBuilder 会通过构造新的 StringBuilder 实例的方式，来创建出一个新的 Chunk。
那么也就是说，在获取 Capacity 以及 Length 时，我们都需要考虑 previous Chunk 的存在，同时在重新设置（setter）Capacity 和 Length 时也要多做一些额外工作。
在探究构造函数和重要的内部实现与对外方法时，会重点关注此部分内容。
构造函数
提供了多个构造函数，可以分别指定初始容量，初始字符串值，指定初始字符串值为给定字符串的一个子串…并且它们均依赖同一份构造函数实现，即
StringBuilder(String value, int startIndex, int length, int capacity)
public StringBuilder(String value, int startIndex, int length, int capacity) {
// 初始参数 startIndex, length, capacity 的一些合法性检测 ...
if (value == null) {
value = String.Empty;
}
// if (startIndex > value.Length - length) { // 越界检测
m_MaxCapacity = Int32.MaxValue;
if (capacity == 0) {
capacity = DefaultCapacity;
}
if (capacity < length)
capacity = length;
m_ChunkChars = new char[capacity];
m_ChunkLength = length;
unsafe {
fixed (char* sourcePtr = value)
ThreadSafeCopy(sourcePtr + startIndex, m_ChunkChars, 0, length);
}
}可以得到以下信息：
- StringBuilder 有默认大小
DefaultCapacity == 16 - StringBuilder 中的字符内容被存储在 m_ChunkChars，并且长度也被记录于 m_ChunkLength
部分关键实现
字符串内容拷贝 StringBuilder.ThreadSafeCopy
字符串内容的拷贝基于 unsafe 方法
static unsafe StringBuilder.ThreadSafeCopy，方法内部做了字符串数组的边界检测，并且基于方法
System.String.wstrcpy 实现了内容的拷贝。
顺带一提，可以看到 System.String.wstrcpy 内部基于
System.Buffer.Memcpy，并且对于每个字符均采用两个字节的长度。使用
charCount * 2 是因为此版本下 C# 中的字符串是以 UTF-16
编码存储的（但注意 UTF-16 也是变长编码）。每个字符占用 2 个字节（16
位），因此需要将字符数乘以 2 来计算字节数。
// ndp\clr\src\BCL\system\text\stringbuilder.cs:1846
if ((uint)destinationIndex <= (uint)destination.Length && (destinationIndex + count) <= destination.Length)
{
fixed (char* destinationPtr = &destination[destinationIndex])
string.wstrcpy(destinationPtr, sourcePtr, count);
}
// ndp\clr\src\BCL\system\string.cs:1546
internal static unsafe void wstrcpy(char *dmem, char *smem, int charCount)
{
Buffer.Memcpy((byte*)dmem, (byte*)smem, charCount * 2); // 2 used everywhere instead of sizeof(char)
}容量的获取与设置 Capacity
从容量的获取不难看出 m_ChunkOffset 即是先前 Chunk 中包含字符串数量。
builder 的 Capacity 是当前chunk的字符偏移值，加上内部数组的大小。
public int Capacity {
get { return m_ChunkChars.Length + m_ChunkOffset; }容量的设置方法中也考虑了 m_ChunkOffset，当前 StringBuilder 的字符数组，会被一个新的字符数组取代（由于做了合法性检测保证新的 Capacity > Length，此处不同担心新的字符数组长度是非法值）
if (Capacity != value) {
int newLen = value - m_ChunkOffset;
char[] newArray = new char[newLen];
Array.Copy(m_ChunkChars, newArray, m_ChunkLength);
m_ChunkChars = newArray;
}长度的获取与设置 Length
builder 的 Length 是当前chunk的字符偏移值，加上内部数组中有效内容的长度。
public int Length {
get {
Contract.Ensures(Contract.Result<int>() >= 0);
return m_ChunkOffset + m_ChunkLength;
}而从容量的设置我们可以看到 StringBuilder 在容量更新时是如何处理多个Chunk的情况的：
首先还是惯例的合法性检测，同时保留当前的容量值
// Sets the length of the String in this buffer. If length is less than the current
// instance, the StringBuilder is truncated. If length is greater than the current
// instance, nulls are appended. The capacity is adjusted to be the same as the length.
public int Length {
set {
//If the new length is less than 0 or greater than our Maximum capacity, bail.
// 一些合法性检测，保证 0 < value <= MaxCapacity
// ... // Contract.EndContractBlock();
int originalCapacity = Capacity;
}
}如果是将 StringBuilder 置空的常见操作，那么只是重置 m_ChunkLength 以及 m_ChunkOffset，没有太多进一步操作了。考虑到将 StringBuilder 重置是一个发生频率比较高的操作，将 m_ChunkChars 中的内容先做保留或许也是正确的选择。
if (value == 0 && m_ChunkPrevious == null)
{
m_ChunkLength = 0;
m_ChunkOffset = 0;
Contract.Assert(Capacity >= originalCapacity, "setting the Length should never decrease the Capacity");
return;
}如果长度发生了增长，那么将填充 delta * ‘\0’
到字符数组的末尾。这个操作和对外方法 Append
并没有区别，都有可能造成新的Chunk增长，但之后在探究
ExpandByABlock
实现时我们会发现这里顶多也只会增长一个Chunk。（可以看到注释评价此处的实现是可以改进的，可能做一个简单的
m_ChunkChars
容量调整，或者直接加上一个新的Chunk都会更简单高效一些）
int delta = value - Length;
// if the specified length is greater than the current length
if (delta > 0)
{
// the end of the string value of the current StringBuilder object is padded with the Unicode NULL character
Append('\0', delta); // We could improve on this, but who does this anyway?
}如果长度发生了缩减，那么通过方法 FindChunkForIndex
先找到对应的chunk，然后分为“是当前chunk”还有“不是当前chunk”来讨论：
如果是当前chunk，那么简单地更新一下 m_ChunkLength 即可；如果不是当前chunk，那么实际的操作是：
- 由于 StringBuilder 的长度发生了缩减，其内部的有效内容也会发生相应的缩减，builder的当前chunk，将被用来取代缩减位置所对应的chunk，下简称为targetChunk。
- 首先，新的内部数组长度，将保证至少能够容纳缩减的这些内容，长度为
originalCapacity - targetChunk.m_ChunkOffset - 其次，targetChunk中的内容将被完整复制到这个新的数组（可能有新length以后的内容，但不要紧，后面 m_ChunkLength 的更新将会无视掉这部分多余的内容）
- 最后，当前chunk将会使用这个新开辟的字符数组，同时继承targetChunk的前向chunk，offset等信息
- 这些被略过，以及被取代掉的chunk，以及它们内部的数组内容都已没有引用，它们所占有的内存空间将在下一次 GC.Collect 时释放掉
// if the specified length is less than or equal to the current length
else
{
StringBuilder chunk = FindChunkForIndex(value);
if (chunk != this)
{
// we crossed a chunk boundary when reducing the Length, we must replace this middle-chunk with a new
// larger chunk to ensure the original capacity is preserved
int newLen = originalCapacity - chunk.m_ChunkOffset;
char[] newArray = new char[newLen];
Contract.Assert(newLen > chunk.m_ChunkChars.Length, "the new chunk should be larger than the one it is replacing");
Array.Copy(chunk.m_ChunkChars, newArray, chunk.m_ChunkLength);
m_ChunkChars = newArray;
m_ChunkPrevious = chunk.m_ChunkPrevious;
m_ChunkOffset = chunk.m_ChunkOffset;
}
m_ChunkLength = value - chunk.m_ChunkOffset;
VerifyClassInvariant();
}清空操作 Clear
简单地提一下，builder的清空操作实际上就是将 Length 设置为0的操作
// Convenience method for sb.Length=0;
public StringBuilder Clear() {
this.Length = 0;
return this;
}字符索引 index
从 index 方法的实现是符合直觉的，如果 index - chunk.offset 大于等于0，那么，字符就在当前chunk中，直接对 m_ChunkChars 进行数组索引；如果小于0，说明字符位于先前的chunk中，chunk指向previous，并使用新的offset更新index值，不断循环即可。
public char this[int index] {
//
get {
StringBuilder chunk = this;
for (; ; )
{
int indexInBlock = index - chunk.m_ChunkOffset;
if (indexInBlock >= 0)
{
if (indexInBlock >= chunk.m_ChunkLength)
throw new IndexOutOfRangeException();
return chunk.m_ChunkChars[indexInBlock];
}
chunk = chunk.m_ChunkPrevious;
if (chunk == null)
throw new IndexOutOfRangeException();
}
}
// set 方法是类似的这就导致如果对很多的chunk组成的builder进行从头到尾的逐字符遍历，实际执行的指令数可能会很多，比如在 System.Net.NetworkingPerfCounters 中的这个方法。
// ndp\fx\src\net\System\Net\_NetworkingPerfCounters.cs:372
// NetworkingPerfCounters.ReplaceInvalidChars
private static string ReplaceInvalidChars(string instanceName)
{
// map invalid characters as suggested by MSDN (see PerformanceCounter.InstanceName Property help)
StringBuilder result = new StringBuilder(instanceName);
for (int i = 0; i < result.Length; i++)
{
switch (result[i])
{
case '(':
result[i] = '[';
break;
case ')':
result[i] = ']';
break;
case '/':
case '\\':
case '#':
result[i] = '_';
break;
}
}
return result.ToString();
}当然，如果instanceName并不长（在这个case中实际上只有一个chunk），那问题就不大。
这警示我们实现自定义index方法时注重可读性，并且在调用其他人写的自定义index方法时，最好也去了解一下具体实现。
输出字符串 ToString()
ToString 方法依赖了 String 类的内部静态方法
String.FastAllocateString，来分配出长度为 Length
的字符串对象 ret，通过 unsafe 得到此目标字符串的地址
destination_ptr。
后续首先将 m_ChunkChars 中的内容通过 unsafe 方式
string.wstrcpy 到目标字符串的
destination_ptr + checkOffset 位置，处理完毕后指向前一个
chunk (StringBuilder)，继续处理，直到所有 chunk
处理完毕，这样完整的字符串构建过程便完成了。
StringBuilder 还提供了可执行从某个位置起指定字符个数版本的
ToString(int startIndex, int length)，这里不再赘述。
分配新的Chunk / ExpandByABlock(int minBlockCharCount)
长度校验：当前字符串总长度 + 新 chunk 需求长度 不可超过
m_MaxCapacity新 chunk 大小计算：此处细节比较多，新分配的一个 chunk 大小将为
Math.Max(minBlockCharCount, Math.Min(Length, MaxChunkSize)), 有以下这些考量- 保证新分配的 chunk 满足需求 minBlockCharCount
- 保证在连续请求（Append）短字符串时，采用总体字符串长度 Length 能保证分配出较长的 chunk，来容纳多个短字符串
- 在此基础上，通过 MaxChunkSize（常量 8000）保证在总体字符串较长的情况下，不会分配出特别大的 chunk，以此来保证分配内存操作保留在 small object heap，而不是 large object heap。这里两种不同 heap 的概念之前没有学习过，可以后续详细了解下。贴上源码中的两处注释以供后续参考：
// ndp\clr\src\bcl\system\text\stringbuilder.cs:76 // We want to keep chunk arrays out of large object heap (< 85K bytes ~ 40K chars) to be sure. // Making the maximum chunk size big means less allocation code called, but also more waste // in unused characters and slower inserts / replaces (since you do need to slide characters over // within a buffer). internal const int MaxChunkSize = 8000; // ndp\clr\src\bcl\system\text\stringbuilder.cs:1977 // Compute the length of the new block we need // We make the new chunk at least big enough for the current need (minBlockCharCount) // But also as big as the current length (thus doubling capacity), up to a maximum // (so we stay in the small object heap, and never allocate really big chunks even if // the string gets really big. int newBlockLength = Math.Max(minBlockCharCount, Math.Min(Length, MaxChunkSize));当前 chunk 通过复制拷贝的方式传递给 m_ChunkPrevious <StringBuilder>，ChunkOffset 增长到扩容前的 Length 值
最后如果发现 ChunkOffset 加上计算出的 newBlockLength 已经超过了 int.MaxInt，发生上溢，会抛出 OutOfMemory 异常
最后，当前 StringBuilder 被作为整个字符串的最后一个 chunk，分配一个大小为 newBlockLength 的内建字符数组给 m_ChunkChars
对外方法
Append
大多数 Append 方法会依赖 unsafe 方法
Append(char* value, int valueCount)，简单处理为两种情况：
- 若需 append 的内容未超过当前 chunk 容量 →
ThreadSafeCopy填充当前 chunk - 需 append 内容超过当前 chunk 容量：
- 将当前 chunk 剩余容量填充满 →
ThreadSafeCopy - 将当前 chunk 复制到内部新的 chunk 作为 previous，当前 chunk
再作为整个字符串中的最后一个 chunk 返回 →
ExpandByABlock(int minBlockCharCount) - 需 append 的剩余内容填充到新的 chunk 中 →
ThreadSafeCopy
- 将当前 chunk 剩余容量填充满 →
Append(String value)
作为使用相当频繁的 Append 方法， 与上述
Append(char* value, int valueCount) 存在些许不同。若 append
新内容后所需长度没有超过当前 chunk 的容量，那么进行简化的操作：
- append 长度不超过2时直接进行字符数组设置
- 超过2时进行 string.wstrcpy 将 append 数组复制到当前 chunk 中
其他情况下使用 AppendHelper，回到上述
Append(char* value, int valueCount) →
ThreadSafeCopy 调用链
CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
StringBuilder 提供将 builder 内指定子串内容复制到目标字符数组的方法
CopyTo，实现基于从后往前的 chunk 遍历搜索 +
ThreadSafeCopy，比较符合直觉，此处不展开。
Insert
大多数 Insert 方法依赖方法
Insert(int index, String value, int count)
，方法除去大多数合法性校验外，核心逻辑集中在两个方法：MakeRoom
以及循环调用 count 次的 ReplaceInPlaceAtChunk
合法性校验中值得额外提及的是，插入字符串总长度 value.Length * cout 加上已有长度 Length 仍然不可超过限定长度 MaxCapacity
StringBuilder chunk;
int indexInChunk;
MakeRoom(index, (int) insertingChars, out chunk, out indexInChunk, false);
unsafe {
fixed (char* valuePtr = value) {
while (count > 0)
{
ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, valuePtr, value.Length);
--count;
}
}
} 方法 MakeRoom 细节如下，先通过向前遍历找到插入位置 index
对应的chunk，接下来若此 chunk 存在足够剩余空间容纳大小为 count
的目标字符串，那么将此处的 count 长度子串移动到 count
个字符之后，腾出空间。
if (!doneMoveFollowingChars && chunk.m_ChunkLength <= DefaultCapacity * 2 && chunk.m_ChunkChars.Length - chunk.m_ChunkLength >= count)
{
for (int i = chunk.m_ChunkLength; i > indexInChunk; )
{
--i;
chunk.m_ChunkChars[i + count] = chunk.m_ChunkChars[i];
}
chunk.m_ChunkLength += count;
return;
} 其他情况下会构造一个容量可容纳 count 字符的新 StringBuilder 作为当前
chunk 的前一个 chunk，对预计算出的插入位置
indexInChunk，将当前chunk的插入位置前内容通过
ThreadSafeCopy 移动到前一个 chunk 中，再将 chunk
和插入位置传出到方法外部，让外部从指定位置开始插入字符串内容。
方法 ReplaceInPlaceAtChunk 将指定的 char* value, int
count 内容通过 ThreadSafeCopy 写入到指定 chunk 中，并且在当前 chunk
无法容纳所有内容时，能够通过索引向后查找下一个 chunk，继续后续的 replace
操作。
不过注意这个操作可行性建立在传入的 chunk 是实际 StringBuilder 的前向
chunk 的基础上，因为 Next() 实际是先得到传入 chunk 的
offset+length，再通过最尾部 chunk 向前查找 offset 的形式实现的。
int lengthInChunk = chunk.m_ChunkLength - indexInChunk;
Contract.Assert(lengthInChunk >= 0, "index not in chunk");
int lengthToCopy = Math.Min(lengthInChunk, count);
ThreadSafeCopy(value, chunk.m_ChunkChars, indexInChunk, lengthToCopy);
// Advance the index.
indexInChunk += lengthToCopy;
if (indexInChunk >= chunk.m_ChunkLength)
{
chunk = Next(chunk);
indexInChunk = 0;
}
count -= lengthToCopy;
if (count == 0)
break;
value += lengthToCopy; Replace
Replace 操作用于将 StringBuilder 中的所有 oldValue 替换为 newValue 字符串，实现细节有以下：
- 以每个 chunk 为单位搜索匹配的字符串，当此 chunk
结束或搜索目标长度完成时，才会一次性进行 replace 操作，replace
操作依赖方法
ReplaceAllInChunk - 每次 replace
操作后字符串长度变化，要找到下一个chunk依赖上述提及的方法
FindChunkForIndex - 再搜索匹配的字符串过程中，方法内部开辟一个 int[] 数组 replacements 用于记录需匹配字符在 chunk 中的下标，同时记录当前 chunk 中匹配的个数 replacementsCount，以保证这个数组在多次 replace 操作间能复用，不需要重新开辟。
- int[] 数组 replacements 的增长速度为
length = 1.5 * length + 4，在起始阶段为更快一些
// Push it on my replacements array (with growth), we will do all replacements in a
// given chunk in one operation below (see ReplaceAllInChunk) so we don't have to slide
// many times.
if (replacements == null)
replacements = new int[5];
else if (replacementsCount >= replacements.Length)
{
int[] newArray = new int[replacements.Length * 3 / 2 + 4]; // grow by 1.5X but more in the begining
Array.Copy(replacements, newArray, replacements.Length);
replacements = newArray;
}
replacements[replacementsCount++] = indexInChunk;
indexInChunk += oldValue.Length;
count -= oldValue.Length; 在设计自己的数据容器时，可以参考此处的容器增长速度。阅读多个数据容器源码后，会发现 1.5x 是一个较常见的增长速度，当然如果追求极致空间利用率，肯定还是需要结合实际业务场景进行调优。
Remove
Remove 操作用于将指定位置 startIndex 位置后 length 长度的内容移除，实现细节有以下：
- 作为一个优化策略，若传入的参数表明要移除所有内容，那么直接通过设置
property
Length = 0的方式来清空整个 StringBuilder 关联的多个 chunks - 其他一般情况下的实现细节在方法
Remove(int startIndex, int count, out StringBuilder chunk, out int indexInChunk)中。 - 先用一个从后向前的 chunk 遍历找到删除范围的起始 chunk，以及终止 chunk。这里在遍历的过程中还会顺带更新每个 chunk 的 offset，因为马上前序的 chunk 就要发生 remove 操作了。
- 如果删除的起始和终止并不在同一个 chunk 中，那么先将起始 chunk 的有效 m_ChunkLength 调整到删除范围的起始（这样被删除的内容虽然还在数组里，实际会被视为无效内容），再将终止 chunk 的前序 chunk 直接链接到起始 chunk 上，并调整终止 chunk 的 offset，相应地从 m_ChunkLength 中减去被移除的长度。
- 最后将终止 chunk 中末端的未删除内容，使用
ThreadSafeCopy向前移动到先前被删除内容的位置（“sliding the characters down”）。 - 这里源码中还考虑了起始 chunk 和终止 chunk 是用一个 chunk 的情况，这样终止 chunk 中的未删除内容就不能直接移动到起始处，而是要移动到此 chunk 中的原删除内容起始处了。
其他
基于 AppendFormat 的 string.Format
见方法实现，实际依赖方法实现
StringBuilder.AppendFormat
注意 StringBuilderCache.Acquire 方法中访问的静态变量
CachedInstance 被标记为 [ThreadStatic]
// ndp\clr\src\BCL\system\String.cs:3054
public static String Format(IFormatProvider provider, String format, params Object[] args) {
if (format == null || args == null)
throw new ArgumentNullException((format == null) ? "format" : "args");
Contract.Ensures(Contract.Result<String>() != null);
Contract.EndContractBlock();
StringBuilder sb = StringBuilderCache.Acquire(format.Length + args.Length * 8);
sb.AppendFormat(provider,format,args);
return StringBuilderCache.GetStringAndRelease(sb);
}
// ndp\clr\src\BCL\system\text\stringbuildercache.cs:50
public static StringBuilder Acquire(int capacity = StringBuilder.DefaultCapacity)
{
if(capacity <= MAX_BUILDER_SIZE)
{
StringBuilder sb = StringBuilderCache.CachedInstance;
if (sb != null)
{
// Avoid stringbuilder block fragmentation by getting a new StringBuilder
// when the requested size is larger than the current capacity
if(capacity <= sb.Capacity)
{
StringBuilderCache.CachedInstance = null;
sb.Clear();
return sb;
}
}
}
return new StringBuilder(capacity);
}平时使用时容易忽视的一个细节是，实际进行字符串格式化时可传入
IFormatProvider，这个参数会被一路传入到方法
StringBuilder.AppendFormat
内部，用于调整字符串格式化行为：
- 如果希望格式化行为不被地区文化影响，可以使用
CultureInfo.InvariantCulture，相应的，使用当前地区文化格式输出是CultureInfo.CurrentCulture。不过对于需要考虑地区文化相关字符串输出格式的应用来说，一般会自己写一套相应地区对应输出格式，还得考虑用户的地区语言设置，也许 CurrentCulture 不是那么常用。 - 在
AppendFormat中，若提供了 IFormatProvider 参数，则会通过其获取 ICustomFormatter 类型对象，并在解析格式占位符（如“{0}”）后，将占位符，参数，以及 provider 一同传递给ICustomFormatter.Format获得结果字符串。 - 否则，
AppendFormat中会尝试将每个格式化参数转换为 IFormattable，并将占位符，provider 一同传递给格式IFormattable.ToString得到格式化结果字符串。常见的基元类型都实现了 IFormattable，但一般我们定义的类型，能有一个输出需求信息的 ToString() 就很好了。AppendFormat 在无法将参数转换为 IFormattable 的情况下，也会回退到一般的 object.ToString() 方法。
一些收获
- StringBuilder 的设计实现思路是把拼接过程中的字符串看作块（chunk）的组合，并使用将外部引用的 StringBuilder 视作是最后一个块，前向块都通过内部 m_PreviousChunk 引用，不暴露给外部。
- 考虑到 AppendFormat 的较复杂实现和潜在内存开辟，在使用 StringBuilder 时也许用普通的 Append 来替代 AppendFormat 可以更好地利用 StringBuilder 的性能优势。当然可读性也很重要。
- 高频使用类型自实现的 index 方法时，最好对 index 方法的实现细节有一些了解；同时在实现自己类型的 index 方法时，也要注意代码可读性。
- 在通用类型的设计完成后，先围绕设计实现一系列基本操作的私有方法，或需求参数较多的公有方法，再考虑易用性，设计传参简单使用便捷的常用公用方法，尽可能少地暴露内部实现细节，减少外围代码使用此通用类型的心智负担。
- 进行常见字符串操作时，留意输出结果是否需要时文化无关的（InvariantCulture）。