C# 中的 Span 和 Memory:看完搞懂高性能内存优化
一句话先行:
Span<T>和Memory<T>是 C# 7.2 引入的"零分配、类型安全、支持栈和堆"的内存访问抽象,核心目标是在不产生 GC 压力的前提下,用统一的方式操作连续内存。
一、为什么需要它们?—— 先看"老问题"
在 Span<T> 出现之前,C# 操作一段连续内存的常见方式:
| 方式 | 问题 |
|---|---|
T[] 数组 | 只能表示堆上的连续内存,无法指向栈、非托管内存 |
ArraySegment<T> | 只能包装数组,不能包装栈内存或非托管内存 |
unsafe + 指针 | 绕过类型安全,需要 unsafe 上下文,无法跨 await |
频繁 Substring / Slice | 每次都分配新对象,GC 压力大 |
核心痛点:缺少一种类型安全、零分配、能统一表示各种连续内存的抽象。
二、Span —— 栈上的内存"视图"
2.1 本质是什么
Span<T> 本质上是一个轻量级的内存片段引用,包含:
- 一个指向内存起始位置的指针
- 一个长度(元素个数)
关键约束:Span<T> 只能存在于栈上(stack-only),不能存在于堆上。
// 指向栈上的数组(ref struct)
Span<byte> buffer = stackalloc byte[128];
// 指向数组的一段
Span<int> slice = new int[100].AsSpan(10, 20); // 取索引10开始的20个元素
// 指向字符串(只读)
ReadOnlySpan<char> name = "Hello".AsSpan(1, 3); // "ell"
2.2 为什么只能放栈上?
Span<T> 内部持有一个 ref 字段(指向内存的引用)。C# 的 GC 只跟踪堆上的引用,如果 Span<T> 被放到堆上,GC 无法追踪它内部的 ref,可能导致悬垂引用(指向已释放的栈内存)。
因此编译器强制 Span<T> 为 ref struct,禁止以下操作:
// ❌ 编译错误
Span<byte> field; // 不能作为类的字段
List<Span<byte>> list; // 不能作为泛型类型参数
Span<byte>[] array; // 不能作为数组元素
Task<Span<byte>> task; // 不能跨 await 返回
2.3 零分配切片(Slice)
这是 Span<T> 最常用、最高效的特性:
byte[] data = new byte[1024];
Span<byte> span = data.AsSpan();
// 切片——零分配!只是调整指针和长度
Span<byte> header = span.Slice(0, 16);
Span<byte> payload = span.Slice(16, 128);
Span<byte> trailer = span.Slice(144);
// 索引器直接访问
header[0] = 0x01;
对比传统方式:
// ❌ 传统方式:每次 Slice 都分配新数组
byte[] header = new byte[16];
Array.Copy(data, 0, header, 0, 16); // 分配 + 拷贝
// ✅ Span 方式:零分配,零拷贝
Span<byte> header = data.AsSpan(0, 16);
2.4 性能对比示例
// 解析 HTTP 请求行(零分配版)
ReadOnlySpan<char> request = "GET /api/users HTTP/1.1".AsSpan();
int firstSpace = request.IndexOf(' ');
int secondSpace = request.Slice(firstSpace + 1).IndexOf(' ');
ReadOnlySpan<char> method = request.Slice(0, firstSpace);
ReadOnlySpan<char> path = request.Slice(firstSpace + 1, secondSpace);
ReadOnlySpan<char> version = request.Slice(firstSpace + 1 + secondSpace + 1);
// 全程零分配,method/path/version 都只是"视图"
三、Memory —— 能上堆的"内存句柄"
3.1 为什么需要 Memory
Span<T> 不能跨 await、不能放堆上,这在很多场景下是致命的:
async Task ProcessAsync()
{
Span<byte> buffer = stackalloc byte[128];
// ❌ 编译错误:不能在 await 后面使用
await DoSomethingAsync();
buffer[0] = 1; // buffer 可能在 await 后失效
}
Memory<T> 就是 Span<T> 的"堆友好版本" :
| 特性 | Span | Memory |
|---|---|---|
| 存储位置 | 仅栈 | 栈或堆 |
| 能否跨 await | ❌ | ✅ |
| 能否做字段 | ❌ | ✅ |
| 能否做泛型参数 | ❌ | ✅ |
| 内部是否含 ref | ✅ | ❌(通过 MemoryManager<T> 间接引用) |
| 访问速度 | 极快(直接指针) | 稍慢(需 .Span 解引用) |
3.2 基本用法
// 包装数组
Memory<byte> memory = new byte[1024];
// 切片——零分配
Memory<byte> slice = memory.Slice(0, 256);
// 在 async 方法中安全使用
async Task ProcessAsync(Memory<byte> buffer)
{
// 获取 Span 来操作(在同步上下文中)
Span<byte> span = buffer.Span;
span[0] = 1;
await Task.Delay(1);
// 再次获取 Span(await 后重新获取,安全)
span = buffer.Span;
span[1] = 2;
}
3.3 Memory 的内部结构
Memory<T>
├── object _object; // 持有数组或 MemoryManager 的引用
├── int _index; // 起始偏移
└── int _length; // 长度
它通过 _object 字段间接引用底层内存,所以可以安全存在于堆上,GC 能正常追踪。
四、ReadOnlySpan 和 ReadOnlyMemory
当内存只读时,使用只读版本:
// 字符串 → ReadOnlySpan<char>(零分配)
ReadOnlySpan<char> text = "Hello World".AsSpan();
// 字节数组 → ReadOnlyMemory<byte>(零分配)
ReadOnlyMemory<byte> rom = new byte[] { 1, 2, 3, 4, 5 };
string 本身不可变,所以天然适配 ReadOnlySpan<char> :
// .NET Core 2.1+ 大量 API 接受 ReadOnlySpan<char>
// 避免 string 分配
int ParseInt(ReadOnlySpan<char> s) { ... }
// 调用
ParseInt("12345".AsSpan()); // 零分配
五、核心 API 全景
5.1 创建方式
// 1. 从数组
Span<int> s1 = new int[10].AsSpan();
Memory<int> m1 = new int[10];
// 2. 从栈分配
Span<byte> s2 = stackalloc byte[64];
// 3. 从非托管内存(需 unsafe)
unsafe
{
byte* ptr = (byte*)NativeMemory.Alloc(64);
Span<byte> s3 = new Span<byte>(ptr, 64);
// 记得释放!
NativeMemory.Free(ptr);
}
// 4. 从 MemoryManager<T>(自定义内存管理)
class CustomMemoryManager : MemoryManager<byte> { ... }
5.2 常用操作
Span<byte> span = stackalloc byte[16];
// 填充
span.Fill(0xFF);
// 拷贝(有边界检查)
span.CopyTo(otherSpan);
// 尝试拷贝(返回 bool)
if (span.TryCopyTo(otherSpan)) { ... }
// 比较
bool equal = span.SequenceEqual(otherSpan);
// 搜索
int index = span.IndexOf((byte)0x00);
// 转为数组(有分配!)
byte[] array = span.ToArray();
5.3 与字符串的互操作
// 字符串 → Span
ReadOnlySpan<char> chars = "Hello".AsSpan();
// Span<byte> → string(UTF-8 场景)
Span<byte> utf8 = stackalloc byte[128];
// ... 填充 utf8 数据
string s = Encoding.UTF8.GetString(utf8);
// .NET 5+ 零分配字符串创建
string result = string.Create(10, state, (span, state) =>
{
// 直接写入 span,零分配
for (int i = 0; i < span.Length; i++)
span[i] = (char)('0' + i);
});
六、实战场景
场景 1:高性能字符串解析
// 传统方式:每次 Substring 都分配新 string
string[] ParseHeader(string header)
{
var parts = new List<string>();
int start = 0;
for (int i = 0; i < header.Length; i++)
{
if (header[i] == ':')
{
parts.Add(header.Substring(start, i - start)); // 分配!
start = i + 1;
}
}
return parts.ToArray(); // 又分配!
}
// Span 方式:零分配
void ParseHeader(ReadOnlySpan<char> header, Span<Range> parts, out int count)
{
count = 0;
int start = 0;
for (int i = 0; i < header.Length; i++)
{
if (header[i] == ':')
{
parts[count++] = new Range(start, i);
start = i + 1;
}
}
}
场景 2:网络协议解析
// 从 Socket 接收数据到栈上缓冲区
Span<byte> buffer = stackalloc byte[4096];
int bytesRead = socket.Receive(buffer);
// 解析协议头(零分配)
ReadOnlySpan<byte> packet = buffer.Slice(0, bytesRead);
ushort magic = BinaryPrimitives.ReadUInt16BigEndian(packet.Slice(0, 2));
ushort length = BinaryPrimitives.ReadUInt16BigEndian(packet.Slice(2, 2));
Span<byte> payload = packet.Slice(4, length);
场景 3:Buffer Pooling(数组池)
// 使用 ArrayPool 避免频繁分配大数组
byte[] rented = ArrayPool<byte>.Shared.Rent(4096);
try
{
Memory<byte> memory = rented.AsMemory(0, 4096);
await ProcessAsync(memory);
}
finally
{
ArrayPool<byte>.Shared.Return(rented);
}
场景 4:避免 async 中的分配
// ❌ 不好:每次调用都分配 byte[]
async Task WriteAsyncBad()
{
byte[] buffer = new byte[1024]; // 分配
await stream.WriteAsync(buffer, 0, buffer.Length);
}
// ✅ 好:使用 ArrayPool + Memory<T>
async Task WriteAsyncGood()
{
byte[] rented = ArrayPool<byte>.Shared.Rent(1024);
try
{
Memory<byte> memory = rented.AsMemory(0, 1024);
await stream.WriteAsync(memory); // 接受 Memory<T>
}
finally
{
ArrayPool<byte>.Shared.Return(rented);
}
}
七、Span vs Memory 选择指南
需要操作连续内存?
│
├── 在同步方法中,且生命周期短?
│ └── ✅ 用 Span<T>(最快,零分配)
│
├── 需要跨 await / 存到字段 / 做缓存?
│ └── ✅ 用 Memory<T>
│
├── 需要跨方法边界传递?
│ ├── 同步方法 → 参数用 Span<T>
│ └── 异步方法 → 参数用 Memory<T>
│
└── 内存只读?
└── 用 ReadOnlySpan<T> / ReadOnlyMemory<T>
八、常见陷阱
⚠️ 陷阱 1:Span 逃逸到堆
// ❌ 编译错误
class Cache
{
Span<byte> _buffer; // 不能做字段
}
// ✅ 正确做法
class Cache
{
byte[] _array; // 存数组
Memory<byte> _memory; // 或存 Memory<T>
}
⚠️ 陷阱 2:await 后使用之前的 Span
async Task Bad()
{
Span<byte> span = stackalloc byte[64];
await Task.Delay(1);
span[0] = 1; // ❌ 编译错误:span 在 await 后不可用
}
// ✅ 正确
async Task Good()
{
Memory<byte> memory = new byte[64];
await Task.Delay(1);
Span<byte> span = memory.Span; // 重新获取
span[0] = 1;
}
⚠️ 陷阱 3:Span 指向已释放的栈内存
Span<byte> GetSpan()
{
Span<byte> local = stackalloc byte[64];
return local; // ❌ 编译错误:local 在函数返回后失效
}
⚠️ 陷阱 4:忘记 ReadOnlySpan 的不可变性
ReadOnlySpan<byte> rom = new byte[] { 1, 2, 3 };
rom[0] = 1; // ❌ 编译错误:只读
九、性能数据(参考)
| 操作 | 传统方式 | Span 方式 | 提升 |
|---|---|---|---|
| 字符串 Substring × 100万 | ~120ms, 分配 ~400MB | ~15ms, 分配 0 | ~8x 快,零分配 |
| 数组 Slice × 100万 | ~80ms, 分配 ~200MB | ~5ms, 分配 0 | ~16x 快,零分配 |
| 协议解析(1KB 包) | ~2μs, 分配 1KB | ~0.3μs, 分配 0 | ~6x 快,零分配 |
数据来源:.NET Runtime 团队基准测试,具体数值因硬件而异
十、总结
| 概念 | 一句话 |
|---|---|
Span<T> | 栈上的零分配内存视图,适合同步、短生命周期的高性能操作 |
Memory<T> | 堆安全的记忆体句柄,适合异步、长生命周期、需要跨 await 的场景 |
ReadOnlySpan<T> | 只读版的 Span,完美适配 string |
ReadOnlyMemory<T> | 只读版的 Memory |
核心心法:
能用
Span<T>就用Span<T>;需要跨await或存堆上,降级到Memory<T>;内存只读就用ReadOnly版本。
