C# 中的 Span<T> 和 Memory<T>:看完搞懂高性能内存优化

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> 的"堆友好版本" :

特性SpanMemory
存储位置仅栈栈或堆
能否跨 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 版本。

0
0
0
0
评论
未登录
暂无评论