一个导出功能上线后,内存曲线像爬楼梯。数据量只有几十万行,按理说不该出问题。打开代码一看,最里面是一个循环,每处理一行就往同一个字符串后面拼一段:result += line。这段代码单次运行看不出问题,跑上几分钟,进程就被拖垮了。

原因不是「字符串太大」,而是字符串根本改不了。每次 += 都会新建一个更长的字符串,把旧内容复制过去,旧的字符串变成垃圾等回收。循环几十万次,复制的总字节数是平方级的,临时对象也堆成山。类似的问题在集合里同样存在:List 不知道要装多少元素时会反复扩容,Dictionary 的键一旦可变就会查不到。

这篇讲 C# 里最常用的几个容器和字符串 API:List 的容量与扩容、Dictionary 和 HashSet 的键、遍历时修改集合的规矩、StringBuilder 的适用场景,以及 Span 和 stackalloc 这种「不想分配内存」的写法。示例在本机 .NET 8 控制台项目里跑过,输出照实贴出;计时的数字和机器有关,换个电脑会变,但数量级差别能说明问题。

先把结论说在前面:这些 API 本身都不难,难的是知道它们内部做了什么、什么时候会付出额外代价。下面每一节都从一段能跑起来的代码开始,先看结果,再解释原因。

List 的容量不是元素个数

List 内部维护一个数组。元素个数叫 Count,数组长度叫 Capacity。添加元素时,如果数组装满了,List 会新建一个更大的数组,把旧元素复制过去,再放新元素。默认的空 List 容量是 0,第一次添加时分配一个能装 4 个元素的数组,之后每次不够就翻倍。

using System;
using System.Collections.Generic;

var list = new List<int>();
for (int i = 1; i <= 20; i++)
{
    list.Add(i);
    if (i == 1 || i == 4 || i == 5 || i == 9 || i == 17)
        Console.WriteLine($"count={list.Count} capacity={list.Capacity}");
}

本机输出:

count=1 capacity=4
count=4 capacity=4
count=5 capacity=8
count=9 capacity=16
count=17 capacity=32

可以看到,容量按 4、8、16、32 递增,而 Count 是一格一格涨。容量大于 Count 时,多出来的位置是空的,不占元素,但占内存。扩容时要把旧数组的元素逐个复制到新数组,这是一次实打实的搬运。元素越多,扩容越贵。

如果提前知道大致数量,用 new List<T>(capacity) 指定初始容量,或者 new List<T>(existing) 从另一个集合复制,都能减少扩容次数。但不要随便猜一个巨大的容量,List 会立刻分配那么大的数组,猜大了反而浪费内存。容量是给「确定会装很多」的场景用的,不是越大越好。

Capacity 和 Count 混用是常见错误。遍历时应该用 list.Count,不要用 list.Capacity,后者包含空位。判断是否为空用 list.Count == 0,不要用 Capacity。要释放多余容量可以调用 TrimExcess(),但它会重新分配并复制,别在热路径里频繁调用。

Dictionary 和 HashSet:键必须稳定

Dictionary 是键值对容器,HashSet 是只存键、不存值的容器。两者都靠哈希值快速定位,平均情况下查找是常数时间。它们对键有一个硬要求:放进容器之后,参与哈希计算的字段不能再改。

看一个用可变类当键的例子:

class Key
{
    public int Id;
    public override int GetHashCode() => Id.GetHashCode();
    public override bool Equals(object? o) => o is Key k && k.Id == Id;
}

class Program
{
    static void Main()
    {
        var key = new Key { Id = 7 };
        var map = new Dictionary<Key, string> { [key] = "seven" };
        key.Id = 8;
        Console.WriteLine($"lookup after mutate: {map.TryGetValue(key, out var hit)} {hit}");
    }
}

本机输出:

lookup after mutate: False 

把键放进去时,字典按 Id=7 算了一个哈希值,把它放在对应的桶里。之后把 Id 改成 8,再拿同一个对象去查,字典按 8 算哈希,跑到另一个桶里找,自然找不到。数据没有丢,只是「地址变了」。结构体当键也有同样的问题,而且更隐蔽,因为结构体是复制进去的,你手里那个和字典里那个已经是两份。

正确做法是让键不可变:把字段改成只读,或者用 record、字符串、整数这类天然稳定的值。如果业务上确实需要改,就先删掉旧键,再插入新键,不要指望字典能感知变化。

Dictionary 还有几个使用习惯值得提前养成。第一,查找用 TryGetValue,不要先判断 ContainsKey 再取,后者会做两次查找。第二,dict[key] 在键不存在时会抛异常,而 dict[key] = value 是新增或覆盖,不会抛。第三,如果键一定存在,用索引器更直接;如果键可能不存在,用 TryGetValue 或 GetValueOrDefault。这几种写法的语义不同,不要混着用。

Dictionary 也可以预设容量。new Dictionary<K, V>(capacity) 会按容量分配桶,减少插入过程中的重新哈希。和 List 一样,容量估计要合理,猜得太大只是浪费内存。

HashSet 的典型用途是去重和集合运算,比如 UnionWith、IntersectWith、ExceptWith。它判断「有没有」很快,但不保证顺序,也不能按下标访问。需要顺序时用 List,需要键值映射时用 Dictionary,需要去重时用 HashSet,别拿一个容器硬干所有事。

遍历时修改集合,为什么会直接抛异常

在 foreach 里给 List 添加或删除元素,会抛 InvalidOperationException,消息是「Collection was modified; enumeration operation may not execute」。这不是框架故意为难人,而是迭代器在遍历时会记录一个版本号,集合每次结构性修改都会把版本号加一。下一次移动迭代器时发现版本对不上,就立即失败。

这个设计的目的是避免「遍历到一半集合变了」带来的不确定结果。与其让你拿到漏掉或重复的元素,不如直接报错。要边遍历边删,有三种常见做法:

  • 倒着用 for 循环从最后一个元素往前删,删除不会影响还没访问的下标。
  • 先收集要删除的元素,遍历结束后再统一删除。
  • 用 RemoveAll 配合条件,让 List 自己处理。

RemoveAll 是最省心的删除方式,它接收一个条件,把所有满足条件的元素删掉,并返回删除的个数:

var nums = new List<int> { 1, 2, 3, 4, 5 };
int removed = nums.RemoveAll(n => n % 2 == 0);
Console.WriteLine($"removed={removed} left={string.Join(",", nums)}");
// removed=2 left=1,3,5

倒序删除的写法是这样,注意循环条件是 i >= 0,每删一个元素后下标要往前退:

for (int i = nums.Count - 1; i >= 0; i--)
{
    if (nums[i] % 2 == 0) nums.RemoveAt(i);
}

如果只是修改元素内容、不改变元素个数,通常不会触发版本号变化,可以正常遍历。但这个边界不要依赖得太死,不同容器的实现细节不一样,最稳妥的方式仍然是「遍历时只读,要改就改副本或改完再遍历」。

在多线程环境里,一个线程遍历、另一个线程添加元素,同样会出问题,而且可能不是每次都抛异常,而是读到脏数据或死循环。List 和 Dictionary 都不是线程安全的容器。需要并发读写时,用 ConcurrentDictionary,或者自己加锁,不要靠「暂时没出错」来判断安全。

字符串拼接:两种写法的真实差距

回到开头那个导出功能。下面这段代码对比了两种写法,都是拼接 20 万个字符,先 +=,再 StringBuilder:

using System;
using System.Diagnostics;
using System.Text;

int count = 200_000;

var sw = Stopwatch.StartNew();
string s = "";
for (int i = 0; i < count; i++) s += "x";
sw.Stop();
Console.WriteLine($"concat ms: {sw.ElapsedMilliseconds}, len={s.Length}");

sw.Restart();
var sb = new StringBuilder();
for (int i = 0; i < count; i++) sb.Append('x');
sw.Stop();
Console.WriteLine($"builder ms: {sw.ElapsedMilliseconds}, len={sb.Length}");

本机 dotnet run 输出:

concat ms: 15081, len=200000
builder ms: 0, len=200000

同样的结果长度,+= 花了 15081 毫秒,StringBuilder 不到 1 毫秒。这个数字和机器性能有关,但差距的量级是稳定的:前者是平方级复制,后者是均摊线性的追加。StringBuilder 内部也有扩容,但它扩容的是可变的字符缓冲区,不需要每次创建新字符串对象。

什么时候不该用 StringBuilder?拼接少量固定片段时,直接用 + 或插值字符串更清楚,编译器也会做一些优化。把三五个字符串拼成一句 SQL 或一条日志,用 StringBuilder 反而增加了阅读负担。判断标准是「是否在循环里」和「总量是否可能很大」,不是「拼接次数大于几」。

还有一种常被忽略的开销:在循环里用插值字符串 $"id={i}",每次都会创建一个新字符串。如果只是往日志里写,问题不大;如果在热路径里生成大量临时字符串,垃圾回收压力会明显上升。必要时可以先拼到 StringBuilder,再统一输出。

StringBuilder 自己也会扩容,默认初始容量不大,元素多了同样要重新分配缓冲区。如果知道最终大概多长,可以在构造时给出容量,例如 new StringBuilder(1024)。追加时优先用 Append 拼接值,少用 AppendFormat 和插值,后两者内部会做格式化,开销更高。

Span 和 stackalloc:省掉分配,但换来限制

Span 是 C# 7.2 引入的一种「切片视图」,它指向一段连续内存,不拥有这段内存。你可以用它截取数组、字符串或栈上内存的一部分,而不产生新对象。stackalloc 则是在当前栈帧上直接分配一块内存,函数返回就自动回收,不经过垃圾回收器。

Span<int> span = stackalloc int[3] { 1, 2, 3 };
Console.WriteLine($"span sum: {span[0] + span[1] + span[2]}");

本机输出 span sum: 6。这段代码没有在堆上分配数组,三个整数直接放在栈上。对于短小的临时缓冲区,这种写法能减少分配和回收。Span 还能接收数组和字符串的切片,例如 "hello".AsSpan(1, 3) 得到 ell 的视图,不复制字符。

string text = "2026-11-07";
ReadOnlySpan<char> year = text.AsSpan(0, 4);
Console.WriteLine(year.ToString());   // 2026

解析固定格式的文本时,用 Span 切片可以避免反复 Substring 产生的临时字符串。注意 ReadOnlySpan<char> 只能读,不能改原字符串;如果只是比较或输出,它足够用。要转回普通字符串时调用 ToString(),这一步仍然会分配。

限制也很明确。Span 是 ref struct,它可能指向栈内存,所以不能作为类的字段长期保存,不能跨 await 使用,也不能装进普通的集合。编译器会在这些场景直接报错,这是为了保护你不拿到已经失效的内存。stackalloc 分配的栈空间也不能太大,栈的大小有限,分配过多会直接栈溢出。

普通数组或字符串

在堆上分配,可以被字段保存、被多个方法共享、跨异步边界传递。代价是分配和垃圾回收,以及切片时可能产生复制。

Span 视图

指向已有内存,不分配、不复制,切片成本极低。生命周期受所在栈帧限制,不能长期保存,不能跨 await,用错场景编译器会直接拦住。

Span 最适合解析文本、处理二进制协议、在热路径里避免临时数组。普通业务代码里,数组和字符串已经够用,不必为了「看起来高性能」到处用 Span。它省下的是分配,付出的是生命周期约束和可读性,划不划算要看具体场景。

还有一个容易忽略的点:Span 切片不检查越界之外的东西,它只保证长度在范围内。切片之后如果原数组被重新分配,Span 仍然指向旧内存。所以不要把一个 Span 保存到比它指向的数组更久的地方,也不要跨线程传递。编译器能拦住大部分错误用法,但拦不住所有逻辑错误。

真实项目里的现象与排查方向

现象真实原因第一步查什么
导出大文件时内存持续上涨循环里用 += 拼字符串,产生大量临时对象找循环里的字符串拼接,改用 StringBuilder 或流式写出
List 添加元素时偶尔卡顿容量不够触发扩容,需要重新分配并复制看是否能在创建时预估容量,或批量添加后再处理
字典里明明放进去的键查不到键对象在放入后被修改,哈希值变了检查键类型是否可变,改为不可变类型或删除后重插
遍历 List 时抛集合已修改异常foreach 期间添加或删除了元素改成倒序 for 删除,或先收集再统一修改
多线程下集合数据错乱List 和 Dictionary 不是线程安全容器改用并发容器,或在所有访问路径上加同一把锁
Span 相关代码编译失败试图把 ref struct 存进字段、集合或跨 await 使用检查生命周期,改成局部使用或退回普通数组
反复截取字符串后内存偏高每次 Substring 都生成新字符串,原字符串仍被引用时无法回收改用 Span 做临时切片,或在源头减少大字符串的长期持有
HashSet 去重后顺序乱了HashSet 不保证顺序,按哈希桶排列需要顺序时改用 List 加去重逻辑,或遍历后排序

排查这类问题时,先分清是「容器行为」还是「数据量问题」。容器行为通常表现为异常、查不到、顺序不对;数据量问题表现为内存、耗时随规模非线性增长。混淆这两类,容易在错误的方向上改代码。

边界与代价

这些容器和 API 各有各的成本,选型时要知道自己放弃了什么:

  • List 适合按顺序访问,不适合频繁中间插入:在头部或中间插入元素,后面的元素都要往后挪,数据量大时很慢。频繁两端操作可以用 LinkedList,但它遍历和内存局部性更差,多数场景反而不如 List。
  • Dictionary 的快是平均情况:哈希冲突严重时查找会退化,键的哈希函数质量很重要。自定义类型做键时,GetHashCode 要稳定且分布均匀。
  • StringBuilder 不是万能:它适合大量追加,不适合频繁在中间插入或删除。最终调用 ToString() 仍会生成一个完整字符串,数据特别大时要考虑流式写出。
  • Span 的生命周期约束是硬性的:它不是「更快的 string」,而是「一段临时视图」。需要跨方法长期保存时,老老实实用数组或字符串。
  • 容量预估可能猜错:指定过大的初始容量会立刻占用内存,指定过小仍会扩容。宁可从合理估值开始,用测量验证,不要凭感觉写一个巨大的数字。
  • 并发容器只保证单个操作安全:ConcurrentDictionary 的单个读写是线程安全的,但「先查再改」这种组合操作仍需要 AddOrUpdate 或锁来保证原子性。
  • 不要为了删除方便就用 LinkedList:它的节点分散在堆上,遍历时缓存不友好,内存占用也比 List 高。只有确实需要频繁在中间插入删除、并且持有节点引用时,它才有优势。

还有一个常见的认识误区:集合的「线程安全」不等于「业务安全」。即使每个操作都原子,两个操作之间的状态仍可能被别的线程改掉。多线程下真正要保护的是业务不变量,而不是单个方法调用。

当天能自己验证的练习

以下练习都在一个控制台项目里完成,改 Program.cs 后执行 dotnet run:

  1. 创建空 List,循环添加 20 个元素,每次打印 Count 和 Capacity,确认扩容发生在 1、5、9、17 这几个位置。
  2. 用 new List<int>(100) 创建列表,重复上面的观察,确认容量一开始就是 100,添加过程不再扩容。
  3. 用可变类做 Dictionary 的键,放入后修改参与哈希的字段,再查询,记录结果;然后改成放入后不修改,再查一次。
  4. 在 foreach 里给 List 添加元素,捕获异常并打印类型和消息;再改成倒序 for 删除,确认不再抛异常。
  5. 把本文的字符串拼接对比跑一遍,记录两种写法的毫秒数,再把循环次数改成 2 万和 20 万,观察差距如何变化。
练习里的计时只用来比较两种写法的相对差距,不要拿绝对值去推断线上性能。不同机器、不同 .NET 版本、Debug 和 Release 配置都会影响结果。真要评估,用 Release 模式多跑几轮取中间值。

小结

三句话收一下:List 的 Count 是元素个数、Capacity 是数组长度,扩容要复制,能预估就预估;Dictionary 和 HashSet 的键必须稳定,放进去之后不要再改;字符串不可变,循环里拼接要用 StringBuilder,Span 能省分配但生命周期受限。

数据在内存里放好之后,下一步要把它写到磁盘、再从磁盘读回来。下一篇讲文件和 JSON:路径怎么拼才安全、编码为什么会导致乱码、一次读整个文件有什么风险,以及 System.Text.Json 的命名策略和日期时区问题。