Span 与 Memory

前置知识#

• 泛型与协变逆变：建议先完成前一篇的学习

学习目标#

• 掌握「1. 历史动机与发展脉络」的核心机制、典型用法与常见陷阱
• 掌握「2. 形式化定义」的核心机制、典型用法与常见陷阱
• 掌握「3. 理论推导与原理解析」的核心机制、典型用法与常见陷阱
• 掌握「4. 代码示例」的核心机制、典型用法与常见陷阱
• 掌握「5. 对比分析」的核心机制、典型用法与常见陷阱

1. 历史动机与发展脉络#

1.1 C/C++ 时代：指针与缓冲区溢出（1970s-2000s）#

C 与 C++ 通过裸指针（T*）操作连续内存，性能极高但安全性极差。典型缺陷包括：

• 缓冲区溢出（buffer overflow）：memcpy(dst, src, n) 中 n 超出 dst 容量，导致栈破坏、堆腐蚀。
• 悬垂指针（dangling pointer）：返回栈数组指针，调用方解引用时栈帧已销毁。
• 越界访问（out-of-bounds）：arr[i] 中 i 未检查，导致未定义行为（UB）。

1988 年 Morris 蠕虫利用 fingerd 缓冲区溢出感染数千台机器，成为安全史上里程碑事件。2014 年 Heartbleed（OpenSSL CVE-2014-0160）同样是缓冲区过度读取漏洞，影响全球 17% 的 HTTPS 服务器。

1.2 .NET 早期：托管数组与 IEnumerable（2002-2010）#

.NET 1.0 通过托管堆（managed heap）与 T[] 数组提供内存安全：

// .NET 1.0 风格
byte[] buffer = new byte[1024];
int n = stream.Read(buffer, 0, buffer.Length);

T[] 优势：

• 边界检查（bounds check）保证越界抛 IndexOutOfRangeException。
• GC 自动回收，无内存泄漏。

痛点：

• 分配开销：每次 new T[n] 都触发堆分配，热路径（hot path）的 GC 压力大。
• 复制开销：Substring、Split、LINQ.ToList 等操作产生大量中间字符串/数组。
• 切片低效：Array.Copy 是 $O(n)$，无法 $O(1)$ 切片。
• 跨 P/Invoke 不便：byte[] 需要 fixed 固定才能传给原生代码。

1.3 C# 7.2：Span 的诞生（2017）#

Span<T> 由 Krzysztof Cwalina（.NET BCL 标准库首席架构师）与 Stephen Toub（.NET 性能团队负责人）主导设计。设计动机：

1. 零拷贝切片：对数组、字符串、原生内存提供统一的 $O(1)$ 切片视图。
2. 栈约束安全：通过 ref struct 保证 Span<T> 不能逃逸到堆，避免 GC 跟踪复杂化。
3. P/Invoke 友好：Span<T> 可以直接包装 stackalloc 内存或原生指针。

C# 7.2 引入 ref struct 与 Span<T>：

// C# 7.2 / .NET Core 2.1
Span<byte> stackBuf = stackalloc byte[256];
stackBuf[0] = 0x42;

ReadOnlySpan<char> hello = "Hello, World".AsSpan()[..5];
// hello = "Hello"，零分配

1.4 .NET Core 2.1：Span 标准化与生态（2018）#

.NET Core 2.1 是 Span<T> 的”产业级发布”：

• Span<T>、Memory<T>、ReadOnlySpan<T>、ReadOnlyMemory<T> 进入 System.Memory NuGet 包，向后兼容 .NET Framework 4.6.1+。
• string.AsSpan()、byte[].AsSpan()、Stream.Read(Span<byte>)、Utf8Parser、Utf8Formatter 等核心 API 落地。
• ASP.NET Core 2.1 的 Kestrel 全面采用 Span<T> 重写，吞吐量提升 2-3 倍。
• ArrayPool<T>.Shared 引入线程局部缓存，降低 new T[] 的分配压力。

1.5 .NET Core 3.0-3.1：性能优化（2019-2020）#

• .NET Core 3.0 引入 MemoryMarshal、CollectionsMarshal、BinaryPrimitives。
• Span<T>.SequenceEqual、IndexOf、Contains 采用 SIMD（SSE2/AVX2）向量化，性能 5-10 倍提升。
• Utf8JsonReader、Utf8JsonWriter 零分配 JSON API 发布。

1.6 .NET 5-7：内存模型扩展（2020-2022）#

1.7 .NET 8-9：极致性能（2023-2024）#

• .NET 8（2023）：Span<T> 内部布局优化（ByReference<T> 改为原生 ref 字段）、CompositeFormat、TensorPrimitives、Random.GetItems(Span<T>)。
• .NET 9（2024）：Span<T>.GetEnumerator 进一步优化、Memory<T>.Pin 改进、SearchValues<T>.Create 支持 ASCII、ZipFile.ExtractToDirectory 使用 Span、Order/OrderDescending 对 Span<T> 原地排序。

1.8 学术背景与理论渊源#

Span<T> 的设计综合了多门内存管理研究：

• Region-based memory management（Tofte-Talpin 1994）：基于区域的内存管理，与 stackalloc 区域语义一致。
• Linear types（Wadler 1990）：线性类型系统，ref struct 的”使用一次即销毁”语义近似线性类型。
• Affine types（Rust）：仿射类型系统，“最多使用一次”，Span<T> 的栈约束与 Rust 借用规则异曲同工。
• Slices in Go（Go 1.0，2009）：[]T 切片是 Span<T> 的设计参考之一，但 Go 切片可逃逸到堆。
• std::span in C++20（2018）：C++ 标准库借鉴 Span<T> 引入 std::span，但无栈约束。
• Buffers in Java（NIO，2002）：ByteBuffer 提供直接内存与堆内存两种模式，但无栈分配。

2. 形式化定义#

2.1 Span 的形式化#

Span<T> 是一个只读的内存视图（read-only view of memory），形式化为：

其中：

• $\text{ref}$ 是指向内存起始位置的引用（C# ref T），可以是托管对象、栈内存、原生内存。
• $\text{length}$ 是视图长度。

关键性质：Span<T> 满足切片封闭性（slice closure）：

且切片是 $O(1)$：

2.2 ReadOnlySpan 的形式化#

ReadOnlySpan<T> 是 Span<T> 的只读版本：

读约束：

2.3 Memory 的形式化#

Memory<T> 是 Span<T> 的”堆可存储”包装：

其中 $\text{owner}$ 是后端存储：

Memory<T> 可以通过 .Span 属性获取 Span<T>：

2.4 ref struct 的形式化#

ref struct 是 C# 7.2 引入的栈约束类型：

形式化约束：

1. 栈约束（Stack-only）：生命周期受限于栈帧。
2. 不可装箱（No boxing）：不能转换为 object/dynamic/System.ValueType。
3. 不可作为类字段（No class field）：只能在 ref struct 中作为字段。
4. 不可跨 async/yield（No async）：不能在 async 方法或 yield return 迭代器中使用。
5. 不可实现接口（No interface，C# 11 前）：ref struct 不能实现接口。
6. 不可作为类型参数（No generic type arg）：不能作为 T 在 List<T> 等泛型中使用。

2.5 切片运算的形式化#

切片 span[start..end] 定义为：

切片复杂度：

对比数组复制 Array.Copy(src, srcIdx, dst, dstIdx, n)：

2.6 零拷贝的形式化#

零拷贝（zero-copy）定义为：

其中 $\text{Alloc}(f)$ 是函数 $f$ 的堆分配字节数，$\text{Copy}(f)$ 是内存复制字节数。

Span<T> 切片满足零拷贝：

但 ToArray() 不满足：

2.7 ECMA-334 的视角#

ECMA-334 §16.4.14（C# 7.2 起）定义 ref struct：

A ref struct is a struct that shall not be boxed, shall not be a field of a non-ref struct, shall not be captured by lambdas or local functions, shall not be used in async methods or iterator methods, and shall not implement interfaces (until C# 11).

ECMA-334 §12.3.2.7 定义 stackalloc：

The stackalloc expression allocates a block of memory on the evaluation stack. The block is automatically reclaimed when the enclosing method returns.

2.8 ECMA-335 的视角#

ECMA-335 Partition I §8.7 定义托管指针（managed pointer）：

A managed pointer (also called byref) is a pointer to a location that is tracked by the GC. It can point to interior of a managed object.

Span<T> 的内部 ref T 字段本质是 ECMA-335 中的 byref，由 GC 跟踪其指向的对象，避免对象移动时悬垂。

2.9 MemoryManager 的形式化#

MemoryManager<T> 是 Memory<T> 的扩展点：

自定义 MemoryManager<T> 可包装原生内存、内存映射文件、共享内存等：

public abstract class MemoryManager<T> : MemoryManager<T>, IMemoryOwner<T>, IDisposable
{
    public abstract Span<T> GetSpan();
    public abstract MemoryHandle Pin(int elementIndex = 0);
    public abstract void Unpin();
    protected internal abstract bool TryGetArray(out ArraySegment<T> segment);
}

3. 理论推导与原理解析#

3.1 Span 的内部布局#

CoreCLR 中 Span<T> 的内部字段（简化自 System.Memory.cs）：

public readonly ref struct Span<T>
{
    internal readonly ByReference<T> _pointer;  // ref T 的内部表示
    private readonly int _length;
}

ByReference<T> 在 .NET 5+ 替换为原生 ref T 字段：

flowchart TD
    S[Span<T> 内存布局，Total 16 bytes]
    S --> R[ref T _reference 8 bytes<br/>指向内存起始]
    S --> L[int _length 4 bytes<br/>视图长度]
    S --> P[padding 4 bytes<br/>对齐填充]

布局（64 位）：

flowchart TD
    S[Span<T> 内存布局，Total 16 bytes]
    S --> R[ref T _reference 8 bytes<br/>指向内存起始]
    S --> L[int _length 4 bytes<br/>视图长度]
    S --> P[padding 4 bytes<br/>对齐填充]

3.2 ref struct 的栈约束保证#

Span<T> 是 ref struct，编译器与运行时联合保证其栈约束：

1. 编译器静态检查（C# 编译器）：检测装箱、字段捕获、async 使用等违规。
2. IL 层 byref 约束（CIL）：ref T 类型只能作为局部变量或参数，不能作为字段（ref struct 例外）。
3. 运行时 GC 跟踪（CoreCLR）：GC 扫描栈帧时识别 ref T 字段，更新其指向（在压缩阶段）。

GC 跟踪 ref T 的关键：

• GC 在标记阶段扫描栈帧时，识别 Span<T> 的 _reference 字段为内部指针（interior pointer）。
• 压缩阶段，若 _reference 指向的对象被移动，GC 更新 _reference 为新地址。
• 这保证 Span<T> 包装托管对象时的安全性。

3.3 切片的 $O(1)$ 实现#

Span<T>.Slice(int start, int length) 实现：

public Span<T> Slice(int start, int length)
{
    if ((ulong)(uint)start + (ulong)(uint)length > (ulong)(uint)_length)
        ThrowHelper.ThrowArgumentOutOfRangeException();
    return new Span<T>(ref Unsafe.Add(ref _reference, start), length);
}

关键点：

• Unsafe.Add(ref T, int) 是 $O(1)$ 指针算术。
• 仅校验边界，不复制数据。
• 返回新的 Span<T>，其 _reference 指向原内存偏移 start * sizeof(T) 处。

3.4 Memory 的三后端架构#

Memory<T> 内部根据后端存储选择不同路径：

public readonly struct Memory<T>
{
    private readonly object _owner;       // Array | MemoryManager<T> | String
    private readonly int _index;
    private readonly int _length;
    
    public Span<T> Span
    {
        get
        {
            if (_owner == null) return default;
            if (_owner is T[] array) return array.AsSpan(_index, _length);
            if (_owner is MemoryManager<T> mm) return mm.GetSpan().Slice(_index, _length);
            if (typeof(T) == typeof(char) && _owner is string s)
                return MemoryMarshal.AsBytes(s.AsSpan(_index, _length)).Cast<byte, T>();
            throw new InvalidOperationException();
        }
    }
}

三后端：

1. T[] 数组：最常见，_index 是数组起始偏移，_length 是切片长度。
2. MemoryManager<T>：自定义内存管理器（如 NativeMemoryManager、MmfMemoryManager）。
3. String：仅 Memory<char> 时使用，字符串数据无需复制。

3.5 ArrayPool 的分层缓存#

ArrayPool<T>.Shared 采用分层缓存策略（共享池实现 ConfigurableArrayPool<T>）：

flowchart LR
    T1[Thread 1 TLS cache size buckets] --> C[Shared central pool per-bucket stacks]
    T2[Thread 2 TLS cache size buckets] --> C
    T3[Thread 3 TLS cache size buckets] --> C

每个线程有独立的线程局部存储（TLS）缓存，每个 bucket 对应一种数组大小（如 32, 64, 128, …, 2^30）。

Rent(minSize) 流程：

1. 计算 bucket 大小（向上取 2 的幂）：bucket = CeilingToPowerOfTwo(minSize)。
2. 优先从 TLS cache 取数组。
3. TLS miss 则从 central pool 的 ConcurrentStack<T[]> 取。
4. Central miss 则 new T[bucket]。

Return(array) 流程：

1. 校验数组大小是否为 2 的幂（否则丢弃）。
2. 清空数组（Array.Clear 默认开启，可通过 clearArray: false 关闭）。
3. 优先放入 TLS cache（容量上限内）。
4. TLS 满则放入 central pool（容量上限内）。
5. Central 满则丢弃，由 GC 回收。

3.6 stackalloc 的栈分配#

stackalloc 在栈上分配内存，由 CLR 在方法返回时自动释放：

// C# 7.2+ 可直接赋给 Span<T>
Span<byte> buf = stackalloc byte[256];

编译为 IL：

.locals init (
    [0] uint8* buf,    // 指针
    [1] valuetype Span`1<uint8> span
)
ldc.i4 256
localloc            // 栈分配
stloc.0             // buf = ...
ldloca.s 1
ldloc.0
ldc.i4 256
call instance void Span`1<uint8>::.ctor(void*, int32)

localloc 是 CIL 指令，在当前栈帧分配指定字节数。方法返回时栈帧弹出，内存自动回收。

风险：stackalloc 过大（如 stackalloc byte[1024*1024]）会触发 StackOverflowException，进程直接终止无法捕获。

3.7 MemoryMarshal 的高级操作#

MemoryMarshal 提供低级 reinterpret 操作：

字节序处理：MemoryMarshal.Read<T> 直接按机器字节序读取，跨平台需配合 BinaryPrimitives.ReadXxxBigEndian/LittleEndian。

3.8 P/Invoke 与 Span 的零拷贝#

P/Invoke 与 Span<T> 结合实现零拷贝原生互操作：

// 旧方式（需要 fixed）
byte[] buf = new byte[1024];
fixed (byte* p = buf)
{
    NativeApi.ProcessBuffer(p, buf.Length);
}

// 新方式（Span 直接）
Span<byte> buf = stackalloc byte[1024];
ref byte ref0 = ref MemoryMarshal.GetReference(buf);
NativeApi.ProcessBuffer(ref buf[0], buf.Length);
// 或通过 ref 传递
NativeApi.ProcessSpan(buf);

P/Invoke 声明：

[DllImport("native")]
public static extern void ProcessSpan(Span<byte> buffer);

CLR 自动将 Span<T> 的 _reference 固定（pin）后传给原生代码，无需显式 fixed。

3.9 Utf8JsonReader 的零分配设计#

Utf8JsonReader 是结构体（struct），直接在调用栈上分配，无堆分配：

public ref struct Utf8JsonReader
{
    private ReadOnlySpan<byte> _buffer;      // JSON 字节流
    private JsonReaderState _state;          // 状态机
    private int _consumed;                   // 已消费字节数
    // ...
}

ref struct 保证：

• 不能跨 async/await，每次调用都是独立的栈帧。
• 不能装箱，避免堆分配。
• _buffer 是 ReadOnlySpan<byte>，零拷贝包装原始字节。

3.10 Span 与 GC 的交互#

Span<T> 与 GC 的交互复杂：

1. 包装托管对象（如 T[]、string）：GC 跟踪 _reference 为内部指针，压缩时更新。
2. 包装栈内存（stackalloc）：GC 不跟踪，但栈帧弹出时自动回收。
3. 包装原生内存（NativeMemory.Alloc）：GC 不跟踪，需手动 NativeMemory.Free。

Memory<T> 通过 _owner 字段让 GC 知道后端存储类型，正确处理。

3.11 SIMD 向量化优化#

Span<T> 的 SequenceEqual、IndexOf、Contains 等方法采用 SIMD 向量化：

// SpanHelpers.SequenceEqual 简化
if (Vector256.IsHardwareAccelerated && length >= Vector256<byte>.Count)
{
    ref byte leftRef = ref MemoryMarshal.GetReference(left);
    ref byte rightRef = ref MemoryMarshal.GetReference(right);
    int vectorSize = Vector256<byte>.Count;
    int i = 0;
    for (; i <= length - vectorSize; i += vectorSize)
    {
        Vector256<byte> v1 = Vector256.Load(ref leftRef, i);
        Vector256<byte> v2 = Vector256.Load(ref rightRef, i);
        if (v1 != v2) return false;
    }
    // 处理尾部
}

SIMD 优化使 SequenceEqual 性能比逐字节快 8-32 倍（AVX2 一次比较 32 字节）。

4. 代码示例#

4.1 基础：Span 与 ReadOnlySpan（C# 12, .NET 8）#

// File: SpanBasics.cs
// C# 12 / .NET 8
using System;
using System.Runtime.InteropServices;

public static class SpanBasics
{
    public static void Demo()
    {
        // 1. 从数组创建 Span
        int[] array = { 1, 2, 3, 4, 5 };
        Span<int> span = array.AsSpan();
        Console.WriteLine($"Length: {span.Length}");  // 5

        // 2. 修改 Span 影响原数组
        span[0] = 100;
        Console.WriteLine(array[0]);  // 100

        // 3. 切片（O(1)，零拷贝）
        Span<int> slice = span[1..4];  // { 2, 3, 4 }
        Console.WriteLine(string.Join(", ", slice.ToArray()));  // 2, 3, 4

        // 4. 从字符串创建 ReadOnlySpan
        ReadOnlySpan<char> text = "Hello, World".AsSpan();
        ReadOnlySpan<char> hello = text[..5];  // "Hello"
        Console.WriteLine(hello.ToString());  // Hello

        // 5. stackalloc 栈分配
        Span<byte> stackBuf = stackalloc byte[64];
        stackBuf[0] = 0x42;
        stackBuf.Fill(0xFF);  // 填充
        Console.WriteLine(stackBuf[0]);  // 255

        // 6. CopyTo
        Span<int> dst = stackalloc int[5];
        span[..5].CopyTo(dst);
        Console.WriteLine(dst[0]);  // 100
    }
}

4.2 Memory 异步使用（C# 12, .NET 8）#

// File: MemoryAsync.cs
// C# 12 / .NET 8
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

public static class MemoryAsync
{
    // Span<T> 不能跨 await，Memory<T> 可以
    public static async Task<int> ReadStreamAsync(
        Stream stream, Memory<byte> buffer, CancellationToken ct = default)
    {
        int totalRead = 0;
        while (totalRead < buffer.Length)
        {
            int read = await stream.ReadAsync(buffer[totalRead..], ct);
            if (read == 0) break;
            totalRead += read;
        }
        return totalRead;
    }

    public static async Task ProcessFileAsync(string path)
    {
        byte[] rented = System.Buffers.ArrayPool<byte>.Shared.Rent(4096);
        try
        {
            Memory<byte> buffer = rented;
            using var fs = File.OpenRead(path);
            int bytesRead = await ReadStreamAsync(fs, buffer);
            
            // 转换为 Span 处理
            ProcessBuffer(buffer[..bytesRead].Span);
        }
        finally
        {
            System.Buffers.ArrayPool<byte>.Shared.Return(rented);
        }
    }

    private static void ProcessBuffer(Span<byte> data)
    {
        // 处理数据
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = (byte)(data[i] ^ 0xAA);  // 简单异或
        }
    }
}

4.3 ArrayPool 池化（C# 12, .NET 8）#

// File: ArrayPoolDemo.cs
// C# 12 / .NET 8
using System;
using System.Buffers;

public static class ArrayPoolDemo
{
    // 反模式：每次 new
    public static byte[] BadProcess(byte[] input)
    {
        byte[] temp1 = new byte[input.Length];     // 分配
        byte[] temp2 = new byte[input.Length * 2]; // 分配
        // 处理...
        return temp2;
    }

    // 正解：使用 ArrayPool
    public static byte[] GoodProcess(byte[] input)
    {
        byte[] temp1 = ArrayPool<byte>.Shared.Rent(input.Length);
        byte[] temp2 = ArrayPool<byte>.Shared.Rent(input.Length * 2);
        try
        {
            // 处理 temp1, temp2
            Span<byte> s1 = temp1.AsSpan(0, input.Length);
            Span<byte> s2 = temp2.AsSpan(0, input.Length * 2);
            input.AsSpan().CopyTo(s1);
            // ... 业务逻辑
            return s2.ToArray();  // 仅最终结果分配
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(temp1);
            ArrayPool<byte>.Shared.Return(temp2);
        }
    }
}

// 自定义 ArrayPool 包装器，支持 using 语法
public sealed class PooledArray<T> : IDisposable
{
    public T[] Array { get; }
    public int Length { get; }
    private bool _returned;

    public PooledArray(int minLength)
    {
        Array = ArrayPool<T>.Shared.Rent(minLength);
        Length = minLength;
    }

    public Span<T> Span => Array.AsSpan(0, Length);

    public void Dispose()
    {
        if (!_returned)
        {
            ArrayPool<T>.Shared.Return(Array);
            _returned = true;
        }
    }
}

// 使用
public class Example
{
    public void Run()
    {
        using var pooled = new PooledArray<byte>(4096);
        Span<byte> buf = pooled.Span;
        buf[0] = 0x42;
        // 自动归还
    }
}

4.4 MemoryMarshal 高级操作（C# 12, .NET 8）#

// File: MemoryMarshalDemo.cs
// C# 12 / .NET 8
using System;
using System.Runtime.InteropServices;

public static class MemoryMarshalDemo
{
    public static void Demo()
    {
        // 1. Cast: int[] -> byte[]
        int[] ints = { 0x12345678, 0x9ABCDEF0 };
        Span<int> intSpan = ints.AsSpan();
        Span<byte> byteSpan = MemoryMarshal.AsBytes(intSpan);
        Console.WriteLine(byteSpan.Length);  // 8（2 * sizeof(int)）

        // 2. Read<T>: 从字节流读结构体
        ReadOnlySpan<byte> data = byteSpan;
        int value = MemoryMarshal.Read<int>(data);
        Console.WriteLine($"0x{value:X}");  // 0x12345678（小端）

        // 3. Write<T>: 写结构体到字节流
        Span<byte> buf = stackalloc byte[8];
        MemoryMarshal.Write(buf, 0xDEADBEEF);
        MemoryMarshal.Write(buf[4..], 0xCAFEBABE);

        // 4. CreateSpan: 从 ref 创建
        int x = 42;
        Span<int> singleSpan = MemoryMarshal.CreateSpan(ref x, 1);
        singleSpan[0] = 100;
        Console.WriteLine(x);  // 100

        // 5. GetArrayDataReference: 跳过边界检查
        int[] arr = { 1, 2, 3, 4, 5 };
        ref int firstRef = ref MemoryMarshal.GetArrayDataReference(arr);
        Console.WriteLine(firstRef);  // 1
        // 注意：手动管理边界，越界未定义
    }

    // 结构体 reinterpret（POD）
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct Header
    {
        public int Magic;
        public short Version;
        public short Flags;
        public int Length;
    }

    public static Header ParseHeader(ReadOnlySpan<byte> data)
    {
        if (data.Length < 12) throw new ArgumentException("Data too short");
        return MemoryMarshal.Read<Header>(data);
    }

    public static void WriteHeader(Span<byte> data, Header header)
    {
        MemoryMarshal.Write(data, ref header);
    }
}

4.5 自定义 SpanWriter/SpanReader（C# 12, .NET 8）#

// File: SpanWriter.cs
// C# 12 / .NET 8
using System;
using System.Buffers.Binary;
using System.Runtime.InteropServices;
using System.Text;

public ref struct SpanWriter
{
    private readonly Span<byte> _buffer;
    private int _position;

    public SpanWriter(Span<byte> buffer)
    {
        _buffer = buffer;
        _position = 0;
    }

    public int Position => _position;
    public int Remaining => _buffer.Length - _position;
    public ReadOnlySpan<byte> Written => _buffer[.._position];

    public void WriteByte(byte value)
    {
        if (_position >= _buffer.Length) throw new InvalidOperationException("Buffer full");
        _buffer[_position++] = value;
    }

    public void WriteInt32BigEndian(int value)
    {
        Ensure(4);
        BinaryPrimitives.WriteInt32BigEndian(_buffer[_position..], value);
        _position += 4;
    }

    public void WriteInt32LittleEndian(int value)
    {
        Ensure(4);
        BinaryPrimitives.WriteInt32LittleEndian(_buffer[_position..], value);
        _position += 4;
    }

    public void WriteUtf8String(ReadOnlySpan<char> value)
    {
        int byteCount = Encoding.UTF8.GetByteCount(value);
        WriteInt32BigEndian(byteCount);  // 长度前缀
        Ensure(byteCount);
        Encoding.UTF8.GetBytes(value, _buffer[_position..]);
        _position += byteCount;
    }

    public void WriteBytes(ReadOnlySpan<byte> data)
    {
        Ensure(data.Length);
        data.CopyTo(_buffer[_position..]);
        _position += data.Length;
    }

    public void WriteStruct<T>(in T value) where T : struct
    {
        int size = Marshal.SizeOf<T>();
        Ensure(size);
        MemoryMarshal.Write(_buffer[_position..], in value);
        _position += size;
    }

    private void Ensure(int count)
    {
        if (_position + count > _buffer.Length)
            throw new InvalidOperationException($"Need {count} bytes, only {Remaining} remaining");
    }
}

public ref struct SpanReader
{
    private readonly ReadOnlySpan<byte> _buffer;
    private int _position;

    public SpanReader(ReadOnlySpan<byte> buffer)
    {
        _buffer = buffer;
        _position = 0;
    }

    public int Position => _position;
    public int Remaining => _buffer.Length - _position;
    public bool IsEnd => _position >= _buffer.Length;

    public byte ReadByte()
    {
        if (_position >= _buffer.Length) throw new InvalidOperationException("End of buffer");
        return _buffer[_position++];
    }

    public int ReadInt32BigEndian()
    {
        Ensure(4);
        int value = BinaryPrimitives.ReadInt32BigEndian(_buffer[_position..]);
        _position += 4;
        return value;
    }

    public ReadOnlySpan<byte> ReadBytes(int count)
    {
        Ensure(count);
        var slice = _buffer.Slice(_position, count);
        _position += count;
        return slice;
    }

    public string ReadUtf8String()
    {
        int byteCount = ReadInt32BigEndian();
        var bytes = ReadBytes(byteCount);
        return Encoding.UTF8.GetString(bytes);
    }

    public T ReadStruct<T>() where T : struct
    {
        int size = Marshal.SizeOf<T>();
        Ensure(size);
        T value = MemoryMarshal.Read<T>(_buffer[_position..]);
        _position += size;
        return value;
    }

    private void Ensure(int count)
    {
        if (_position + count > _buffer.Length)
            throw new InvalidOperationException($"Need {count} bytes, only {Remaining} remaining");
    }
}

// 使用示例：二进制协议
public class ProtocolExample
{
    public static void Demo()
    {
        Span<byte> buf = stackalloc byte[256];
        
        // 写入
        var writer = new SpanWriter(buf);
        writer.WriteInt32BigEndian(0x4D414749);  // "MAGI"
        writer.WriteByte(1);                      // version
        writer.WriteUtf8String("Hello, World");
        writer.WriteInt32LittleEndian(42);

        // 读取
        var reader = new SpanReader(writer.Written);
        int magic = reader.ReadInt32BigEndian();
        byte version = reader.ReadByte();
        string message = reader.ReadUtf8String();
        int number = reader.ReadInt32LittleEndian();
        
        Console.WriteLine($"Magic: 0x{magic:X}, Ver: {version}, Msg: {message}, Num: {number}");
    }
}

4.6 Utf8JsonReader 零分配 JSON 解析（C# 12, .NET 8）#

// File: ZeroAllocJson.cs
// C# 12 / .NET 8
using System;
using System.Text;
using System.Text.Json;

public static class ZeroAllocJson
{
    // 传统方式：分配大量字符串
    public static Person ParseBad(string json)
    {
        return JsonSerializer.Deserialize<Person>(json);
    }

    // 零分配方式：Utf8JsonReader
    public static Person ParseGood(ReadOnlySpan<byte> json)
    {
        var reader = new Utf8JsonReader(json);
        string name = "";
        int age = 0;
        bool active = false;

        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.PropertyName)
            {
                string prop = reader.GetString();
                reader.Read();
                switch (prop)
                {
                    case "name":
                        name = reader.GetString();
                        break;
                    case "age":
                        age = reader.GetInt32();
                        break;
                    case "active":
                        active = reader.GetBoolean();
                        break;
                }
            }
        }

        return new Person(name, age, active);
    }

    public record Person(string Name, int Age, bool Active);

    // 流式解析大 JSON（避免全量加载）
    public static async IAsyncEnumerable<Person> ParseStreamAsync(
        Stream stream, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct = default)
    {
        byte[] buffer = System.Buffers.ArrayPool<byte>.Shared.Rent(4096);
        try
        {
            var readerState = new JsonReaderState();
            int bytesInBuffer = 0;

            while (true)
            {
                int read = await stream.ReadAsync(buffer.AsMemory(bytesInBuffer), ct);
                if (read == 0) break;
                bytesInBuffer += read;

                bool isFinalBlock = false;
                ReadOnlySpan<byte> span = buffer.AsSpan(0, bytesInBuffer);
                var reader = new Utf8JsonReader(span, isFinalBlock, readerState);

                while (reader.Read())
                {
                    // 处理 token...
                }

                readerState = reader.CurrentState;
                bytesInBuffer -= (int)reader.BytesConsumed;
                if (bytesInBuffer > 0)
                {
                    buffer.AsSpan((int)reader.BytesConsumed, bytesInBuffer).CopyTo(buffer);
                }
            }
        }
        finally
        {
            System.Buffers.ArrayPool<byte>.Shared.Return(buffer);
        }
    }
}

4.7 零拷贝字符串解析（C# 12, .NET 8）#

// File: ZeroAllocString.cs
// C# 12 / .NET 8
using System;

public static class ZeroAllocString
{
    // 传统：Substring 分配新字符串
    public static int ParseIntBad(string s)
    {
        string trimmed = s.Trim();
        string digits = trimmed.Replace("-", "");
        return int.Parse(digits);
    }

    // 零分配：Span 处理
    public static bool TryParseInt(ReadOnlySpan<char> s, out int result)
    {
        result = 0;
        s = s.Trim();
        if (s.IsEmpty) return false;

        bool negative = false;
        int i = 0;
        if (s[0] == '-')
        {
            negative = true;
            i = 1;
        }
        else if (s[0] == '+')
        {
            i = 1;
        }

        int value = 0;
        for (; i < s.Length; i++)
        {
            char c = s[i];
            if (c < '0' || c > '9') return false;
            value = value * 10 + (c - '0');
            if (value < 0) return false;  // 溢出
        }

        result = negative ? -value : value;
        return true;
    }

    // CSV 零分配解析
    public static void ParseCsvLine(ReadOnlySpan<char> line, Action<int, ReadOnlySpan<char>> processField)
    {
        int start = 0;
        int column = 0;
        for (int i = 0; i <= line.Length; i++)
        {
            if (i == line.Length || line[i] == ',')
            {
                ReadOnlySpan<char> field = line[start..i];
                processField(column, field);
                start = i + 1;
                column++;
            }
        }
    }

    // URL 零分配解析
    public readonly record struct UrlParts(
        ReadOnlySpan<char> Scheme,
        ReadOnlySpan<char> Host,
        ReadOnlySpan<char> Path,
        ReadOnlySpan<char> Query);

    public static UrlParts ParseUrl(ReadOnlySpan<char> url)
    {
        int schemeEnd = url.IndexOf("://");
        if (schemeEnd < 0) return default;

        var scheme = url[..schemeEnd];
        var rest = url[(schemeEnd + 3)..];

        int hostEnd = rest.IndexOf('/');
        ReadOnlySpan<char> host, path, query;
        if (hostEnd < 0)
        {
            host = rest;
            path = ReadOnlySpan<char>.Empty;
            query = ReadOnlySpan<char>.Empty;
        }
        else
        {
            host = rest[..hostEnd];
            var afterHost = rest[hostEnd..];
            int queryStart = afterHost.IndexOf('?');
            if (queryStart < 0)
            {
                path = afterHost;
                query = ReadOnlySpan<char>.Empty;
            }
            else
            {
                path = afterHost[..queryStart];
                query = afterHost[(queryStart + 1)..];
            }
        }

        return new UrlParts(scheme, host, path, query);
    }

    public static void Demo()
    {
        // int 解析
        if (TryParseInt("  -12345  ".AsSpan(), out int n))
            Console.WriteLine(n);  // -12345

        // CSV 解析
        ParseCsvLine("a,b,c,d".AsSpan(), (col, val) =>
            Console.WriteLine($"Col {col}: {val.ToString()}"));

        // URL 解析
        var parts = ParseUrl("https://api.example.com/users/42?active=true".AsSpan());
        Console.WriteLine($"Scheme: {parts.Scheme.ToString()}");
        Console.WriteLine($"Host:   {parts.Host.ToString()}");
        Console.WriteLine($"Path:   {parts.Path.ToString()}");
        Console.WriteLine($"Query:  {parts.Query.ToString()}");
    }
}

4.8 自定义 MemoryManager（C# 12, .NET 8）#

// File: NativeMemoryManager.cs
// C# 12 / .NET 8
using System;
using System.Buffers;
using System.Runtime.InteropServices;

public sealed class NativeMemoryManager<T> : MemoryManager<T> where T : struct
{
    private unsafe T* _pointer;
    private readonly int _length;
    private bool _disposed;

    public NativeMemoryManager(int length)
    {
        if (length < 0) throw new ArgumentOutOfRangeException(nameof(length));
        _length = length;
        unsafe
        {
            _pointer = (T*)NativeMemory.Alloc((nuint)(length * Marshal.SizeOf<T>()));
            if (_pointer == null) throw new OutOfMemoryException();
        }
    }

    public override Span<T> GetSpan()
    {
        unsafe
        {
            if (_disposed) throw new ObjectDisposedException(nameof(NativeMemoryManager<T>));
            return new Span<T>(_pointer, _length);
        }
    }

    public override MemoryHandle Pin(int elementIndex = 0)
    {
        unsafe
        {
            if (_disposed) throw new ObjectDisposedException(nameof(NativeMemoryManager<T>));
            return new MemoryHandle(_pointer + elementIndex);
        }
    }

    public override void Unpin()
    {
        // 原生内存不需要 pin/unpin
    }

    protected override void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            unsafe
            {
                if (_pointer != null)
                {
                    NativeMemory.Free(_pointer);
                    _pointer = null;
                }
            }
            _disposed = true;
        }
    }

    ~NativeMemoryManager()
    {
        Dispose(false);
    }
}

// 内存映射文件 MemoryManager
public sealed class MmfMemoryManager : MemoryManager<byte>
{
    private readonly Microsoft.Win32.SafeHandles.SafeFileHandle _fileHandle;
    private readonly IntPtr _mapping;
    private readonly IntPtr _view;
    private readonly long _length;
    private bool _disposed;

    public MmfMemoryManager(string path, long length)
    {
        _length = length;
        // 简化：实际实现需调用 CreateFileMapping/MapViewOfFile
        // 此处省略 P/Invoke 细节
        throw new NotImplementedException("Demo only");
    }

    public override Span<byte> GetSpan()
    {
        unsafe
        {
            return new Span<byte>(_view.ToPointer(), (int)_length);
        }
    }

    public override MemoryHandle Pin(int elementIndex = 0)
    {
        unsafe { return new MemoryHandle((_view + elementIndex).ToPointer()); }
    }

    public override void Unpin() { }

    protected override void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            // UnmapViewOfFile, CloseHandle, etc.
            _disposed = true;
        }
    }
}

// 使用
public class NativeMemoryExample
{
    public static void Demo()
    {
        using var manager = new NativeMemoryManager<int>(1024);
        Memory<int> mem = manager.Memory;
        Span<int> span = mem.Span;

        for (int i = 0; i < span.Length; i++)
            span[i] = i * 2;

        // 异步传递 Memory<T>
        _ = ProcessAsync(mem);
    }

    private static async Task ProcessAsync(Memory<int> data)
    {
        await Task.Delay(100);
        Console.WriteLine($"Processed {data.Length} elements");
    }
}

4.9 P/Invoke 零拷贝（C# 12, .NET 8）#

// File: PInvokeSpan.cs
// C# 12 / .NET 8
using System;
using System.Runtime.InteropServices;

public static class PInvokeSpan
{
    // 旧方式：byte[] + fixed
    [DllImport("native.dll")]
    private static extern unsafe int ProcessBuffer(byte* buffer, int length);

    public static int OldProcess(byte[] data)
    {
        unsafe
        {
            fixed (byte* p = data)
            {
                return ProcessBuffer(p, data.Length);
            }
        }
    }

    // 新方式：Span 直接
    [DllImport("native.dll")]
    private static extern int ProcessSpan(Span<byte> buffer);

    public static int NewProcess(Span<byte> data)
    {
        return ProcessSpan(data);
    }

    // ref 形式
    [DllImport("native.dll")]
    private static extern int ProcessRef(ref byte buffer, int length);

    public static int NewProcessRef(Span<byte> data)
    {
        return ProcessRef(ref data.GetPinnableReference(), data.Length);
    }

    // Windows API 示例：ReadFile
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern unsafe bool ReadFile(
        Microsoft.Win32.SafeHandles.SafeFileHandle hFile,
        Span<byte> buffer,
        int nNumberOfBytesToRead,
        out int lpNumberOfBytesRead,
        IntPtr lpOverlapped);

    public static int ReadFileSpan(Microsoft.Win32.SafeHandles.SafeFileHandle handle, Span<byte> buffer)
    {
        ReadFile(handle, buffer, buffer.Length, out int read, IntPtr.Zero);
        return read;
    }

    // crypto_api 示例
    [StructLayout(LayoutKind.Sequential)]
    public struct CryptoCtx
    {
        public IntPtr State;
        public int BlockSize;
        public int Rounds;
    }

    [DllImport("crypto.dll")]
    private static extern int Encrypt(
        ref CryptoCtx ctx,
        ReadOnlySpan<byte> plaintext,
        Span<byte> ciphertext);

    public static void EncryptData(CryptoCtx ctx, byte[] plain, byte[] cipher)
    {
        Encrypt(ref ctx, plain, cipher);
    }
}

4.10 高性能字符串拼接（C# 12, .NET 8）#

// File: StringConcat.cs
// C# 12 / .NET 8
using System;
using System.Text;

public static class StringConcat
{
    // 传统方式：StringBuilder 分配
    public static string BuildBad(string[] parts)
    {
        var sb = new StringBuilder();
        foreach (var p in parts)
        {
            sb.Append(p);
            sb.Append(',');
        }
        return sb.ToString();
    }

    // 零分配方式：先计算长度，再 stackalloc
    public static string BuildGood(ReadOnlySpan<string> parts)
    {
        // 计算总长度
        int totalLength = 0;
        foreach (var p in parts) totalLength += p.Length + 1;
        if (totalLength == 0) return string.Empty;

        // 栈分配（小字符串）
        if (totalLength <= 256)
        {
            Span<char> buf = stackalloc char[totalLength];
            int pos = 0;
            foreach (var p in parts)
            {
                p.AsSpan().CopyTo(buf[pos..]);
                pos += p.Length;
                buf[pos++] = ',';
            }
            return buf.ToString();
        }

        // 大字符串：ArrayPool
        char[] rented = System.Buffers.ArrayPool<char>.Shared.Rent(totalLength);
        try
        {
            Span<char> buf = rented.AsSpan(0, totalLength);
            int pos = 0;
            foreach (var p in parts)
            {
                p.AsSpan().CopyTo(buf[pos..]);
                pos += p.Length;
                buf[pos++] = ',';
            }
            return buf.ToString();
        }
        finally
        {
            System.Buffers.ArrayPool<char>.Shared.Return(rented);
        }
    }

    // string.Create 零分配构造
    public static string BuildWithCreate(ReadOnlySpan<string> parts)
    {
        int totalLength = 0;
        foreach (var p in parts) totalLength += p.Length + 1;
        if (totalLength == 0) return string.Empty;

        return string.Create(totalLength, parts, (span, state) =>
        {
            int pos = 0;
            foreach (var p in state)
            {
                p.AsSpan().CopyTo(span[pos..]);
                pos += p.Length;
                span[pos++] = ',';
            }
        });
    }
}

4.11 SearchValues 高性能查找（C# 12, .NET 8）#

// File: SearchValuesDemo.cs
// C# 12 / .NET 8
using System;
using System.Buffers;

public static class SearchValuesDemo
{
    // .NET 8 引入 SearchValues<T>，预计算 SIMD 查找表
    private static readonly SearchValues<char> s_whitespace =
        SearchValues.Create(" \t\r\n".AsSpan());

    private static readonly SearchValues<byte> s_hexDigits =
        SearchValues.Create((ReadOnlySpan<byte>)"0123456789abcdefABCDEF"u8);

    private static readonly SearchValues<char> s_delimiters =
        SearchValues.Create(",;| \t".AsSpan());

    public static ReadOnlySpan<char> Trim(ReadOnlySpan<char> s)
    {
        return s.TrimStart(s_whitespace).TrimEnd(s_whitespace);
    }

    public static int IndexOfFirstDelimiter(ReadOnlySpan<char> s)
    {
        return s.IndexOfAny(s_delimiters);
    }

    public static bool IsHex(ReadOnlySpan<byte> s)
    {
        return !s.ContainsAnyExcept(s_hexDigits);
    }

    // 高性能 Base64 解码
    private static readonly SearchValues<byte> s_base64Chars =
        SearchValues.Create((ReadOnlySpan<byte>)
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"u8);

    public static bool IsValidBase64(ReadOnlySpan<byte> s)
    {
        // 长度必须是 4 的倍数（可含 padding）
        if (s.Length % 4 != 0) return false;
        // 移除 padding
        var core = s;
        while (core.Length > 0 && core[^1] == (byte)'=')
            core = core[..^1];
        return !core.ContainsAnyExcept(s_base64Chars);
    }
}

4.12 BinaryPrimitives 字节序处理（C# 12, .NET 8）#

// File: BinaryPrimitivesDemo.cs
// C# 12 / .NET 8
using System;
using System.Buffers.Binary;

public static class BinaryPrimitivesDemo
{
    // 网络字节序（大端）
    public static void WriteNetworkInt(Span<byte> buf, int value)
    {
        BinaryPrimitives.WriteInt32BigEndian(buf, value);
    }

    public static int ReadNetworkInt(ReadOnlySpan<byte> buf)
    {
        return BinaryPrimitives.ReadInt32BigEndian(buf);
    }

    // 小端（x86/x64 默认）
    public static void WriteLittleEndianInt(Span<byte> buf, int value)
    {
        BinaryPrimitives.WriteInt32LittleEndian(buf, value);
    }

    // 处理协议头
    public readonly record struct PacketHeader(
        uint Magic,
        ushort Version,
        ushort Flags,
        uint Length);

    public static PacketHeader ParsePacket(ReadOnlySpan<byte> data)
    {
        if (data.Length < 12) throw new ArgumentException("Too short");
        return new PacketHeader(
            Magic: BinaryPrimitives.ReadUInt32BigEndian(data[..4]),
            Version: BinaryPrimitives.ReadUInt16BigEndian(data[4..6]),
            Flags: BinaryPrimitives.ReadUInt16BigEndian(data[6..8]),
            Length: BinaryPrimitives.ReadUInt32BigEndian(data[8..12]));
    }

    public static void WritePacket(Span<byte> data, PacketHeader header)
    {
        BinaryPrimitives.WriteUInt32BigEndian(data[..4], header.Magic);
        BinaryPrimitives.WriteUInt16BigEndian(data[4..6], header.Version);
        BinaryPrimitives.WriteUInt16BigEndian(data[6..8], header.Flags);
        BinaryPrimitives.WriteUInt32BigEndian(data[8..12], header.Length);
    }
}

5. 对比分析#

5.1 与 Rust &[T] / &mut [T] 对比#

设计差异：Rust 借用检查器是编译期完全静态的，而 C# ref struct 的栈约束也是编译期静态的，但 C# 仍允许 unsafe 直接操作指针，安全性略弱于 Rust。

5.2 与 Go []T slice 对比#

设计差异：Go slice 是堆可存储的，因此可以跨 goroutine 传递，但 GC 必须跟踪每个 slice 的指针。C# Span<T> 通过栈约束避免 GC 跟踪复杂化，但代价是不能跨 async。

5.3 与 Java ByteBuffer 对比#

设计差异：Java ByteBuffer 是堆上对象，无法栈分配，每次创建都有堆分配开销。C# Span<T> 通过 stackalloc 实现真正的栈分配，零 GC 压力。

5.4 与 C++ std::span（C++20）对比#

设计差异：C++ std::span 是 C# Span<T> 的”无栈约束版本”，更灵活但更危险。C# 通过 ref struct 强制栈约束，避免悬垂指针。

5.5 与 Swift ArraySlice 对比#

5.6 与 Python memoryview 对比#

5.7 综合对比表#

6. 常见陷阱与最佳实践#

6.1 陷阱：Span 跨 async/await#

// 不支持 错误：Span<T> 不能跨 await
public async Task BadAsync()
{
    Span<byte> buf = stackalloc byte[1024];
    await Task.Delay(100);
    Process(buf);  // 编译错误！
}

// 已达标 正解：使用 Memory<T>
public async Task GoodAsync()
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(1024);
    try
    {
        Memory<byte> buf = rented;
        await Task.Delay(100);
        Process(buf.Span);
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(rented);
    }
}

原理：async 方法被编译为状态机，Span<T> 作为 ref struct 不能作为状态机字段（因为状态机是类，类字段不能是 ref struct）。

6.2 陷阱：Span 作为类字段#

// 不支持 错误：ref struct 不能作为类字段
public class BadHolder
{
    private Span<int> _data;  // 编译错误！
}

// 已达标 正解：使用 Memory<T>
public class GoodHolder
{
    private Memory<int> _data;
    public GoodHolder(int[] array) => _data = array;
    public void Process() => ProcessSpan(_data.Span);
}

例外：ref struct 内部可以持有 Span<T> 字段：

public ref struct SpanWriter
{
    private Span<byte> _buffer;  // OK
}

6.3 陷阱：Span 在 Lambda 捕获#

// 不支持 错误：Lambda 不能捕获 Span<T>
public void BadLambda(Span<int> data)
{
    Action a = () => Console.WriteLine(data[0]);  // 编译错误！
}

// 已达标 正解：传递参数
public void GoodLambda(Span<int> data)
{
    Process(data, x => Console.WriteLine(x));
}

private void Process<T>(Span<T> data, Action<T> action)
{
    for (int i = 0; i < data.Length; i++)
        action(data[i]);
}

6.4 陷阱：stackalloc 返回#

// 不支持 错误：返回 stackalloc 内存
public unsafe Span<byte> BadReturn()
{
    Span<byte> buf = stackalloc byte[1024];
    return buf;  // 栈帧弹出后悬垂！
}

// 已达标 正解：使用堆分配
public Span<byte> GoodReturn()
{
    return new byte[1024];
}

// 已达标 正解：使用 ArrayPool
public Memory<byte> GoodReturnPooled()
{
    return ArrayPool<byte>.Shared.Rent(1024);
}

6.5 陷阱：Memory.Span 频繁访问#

// 不支持 低效：每次访问 .Span 都有开销
public void BadProcess(Memory<int> mem)
{
    for (int i = 0; i < mem.Length; i++)
    {
        mem.Span[i] = i;  // 每次都获取 Span
    }
}

// 已达标 高效：缓存 Span
public void GoodProcess(Memory<int> mem)
{
    Span<int> span = mem.Span;
    for (int i = 0; i < span.Length; i++)
    {
        span[i] = i;
    }
}

原理：Memory<T>.Span 属性内部需要判断后端类型（T[]、MemoryManager<T>、String），开销虽小但循环中累积。

6.6 陷阱：ArrayPool 未归还#

// 不支持 错误：忘记 Return
public byte[] BadProcess(byte[] input)
{
    byte[] temp = ArrayPool<byte>.Shared.Rent(input.Length);
    // 处理...
    return temp;  // 没有归还！内存泄漏
}

// 已达标 正解：try-finally 归还
public byte[] GoodProcess(byte[] input)
{
    byte[] temp = ArrayPool<byte>.Shared.Rent(input.Length);
    try
    {
        // 处理...
        byte[] result = new byte[input.Length];
        temp.AsSpan(0, input.Length).CopyTo(result);
        return result;
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(temp);
    }
}

更优解：使用 IMemoryOwner<T>：

public IMemoryOwner<byte> ProcessWithOwner(byte[] input)
{
    var owner = MemoryPool<byte>.Shared.Rent(input.Length);
    input.AsSpan().CopyTo(owner.Memory.Span);
    return owner;  // 调用方负责 Dispose
}

6.7 陷阱：ReadOnlySpan 误用为可写#

// 不支持 错误：字符串是只读的，不能修改
public void BadModify(string s)
{
    Span<char> span = s.AsSpan();  // 编译错误：ROSpan 不能赋给 Span
    span[0] = 'X';
}

// 已达标 正解：转换为 char[] 再修改
public string GoodModify(string s)
{
    char[] chars = s.ToCharArray();
    chars[0] = 'X';
    return new string(chars);
}

6.8 陷阱：Span 切片越界#

// 不支持 错误：越界抛 IndexOutOfRangeException
public void BadSlice(Span<int> data)
{
    var slice = data[..100];  // 若 data.Length < 100 抛异常
}

// 已达标 正解：先检查
public void GoodSlice(Span<int> data)
{
    if (data.Length < 100) throw new ArgumentException("Too short");
    var slice = data[..100];
}

// 已达标 正解：使用 Math.Min
public void SafeSlice(Span<int> data)
{
    var slice = data[..Math.Min(100, data.Length)];
}

6.9 陷阱：固定对象与 GC#

// 不支持 错误：长时间固定 byte[]
public void BadPin(byte[] data)
{
    GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
    // 长时间持有... GC 无法压缩堆
    DoSomething();
    handle.Free();
}

// 已达标 正解：使用 POH（.NET 5+）
public void GoodPoh()
{
    byte[] data = GC.AllocateArray<byte>(1024, pinned: true);
    // 直接使用，无需手动固定
    DoSomething();
}

// 已达标 正解：使用 fixed（短期）
public void FixedShort(byte[] data)
{
    fixed (byte* p = data)
    {
        // 短期使用
        NativeApi.Process(p, data.Length);
    }  // fixed 自动释放
}

6.10 陷阱：多线程共享 Span#

// 不支持 错误：Span<T> 跨线程不安全
public void BadThread(Span<int> data)
{
    Task.Run(() => Process(data));  // 编译错误！Span 不能跨任务
}

// 已达标 正解：使用 Memory<T>
public void GoodThread(Memory<int> data)
{
    Task.Run(() => Process(data.Span));
}

private void Process(Span<int> data)
{
    // 注意：Span 不是线程安全的，即使通过 Memory 传递也要避免并发访问
    for (int i = 0; i < data.Length; i++)
        data[i] = i * 2;
}