Span<T> 与 Memory<T>

是什么，为什么存在

Span<T> 是连续 T 元素区域上的可读写视图。它可以引用数组的一段、由 stackalloc 创建的栈内存，或者受控的非托管内存。视图本身只描述一段区域，不接管该区域的所有权。

切片、协议解析和缓冲区处理经常只需要原数据的一部分。若每一步都创建子数组或子字符串，代码会复制数据并产生新对象；span 让调用方把「这段现有数据」直接交给同步方法。只有后续显式调用 ToArray()、ToString() 等物化操作时，才会得到独立副本。

ReadOnlySpan<T> 去掉通过该视图写入的能力，适合只读参数和字符串片段。它表达的是访问权限，不是深层不可变性：另一个别名仍可修改同一数组，而已有的只读视图会观察到修改。

Memory<T> 与 ReadOnlyMemory<T> 表示可以存储的连续内存区域。它们不是 ref struct ，因此能作为类字段，也能跨异步暂停点保留；实际同步读写时，通过 .Span 取得短生命周期视图。

这四个类型解决的是视图和生命周期表达，不是自动的所有权管理。数组拥有自身存储，字符串管理自身字符，IMemoryOwner<T> 管理租用区域；Span<T> 或 Memory<T> 只借用相应区域。API 必须另外说明谁能修改、谁负责释放，以及借用何时结束。

选择入口参数时，先问方法是否只在当前同步调用内使用数据。答案为是时，优先接受 ReadOnlySpan<T> 或 Span<T>，这样数组、字符串和其他连续来源都能调用；若方法需要保存参数或在 await 后继续使用，则接受 ReadOnlyMemory<T> 或 Memory<T>。

工作原理

视图由区域决定

可以把一个视图理解为底层存储、起始位置和长度的组合。Slice(start, length) 或范围运算符创建新视图，新旧视图仍指向同一存储。切片的索引从当前视图起点计算，而不是从原始所有者的起点计算。

运行时仍会检查视图边界。构造或切片超出合法范围会抛出异常，索引访问也不能越过视图长度。类型安全和边界检查并不验证业务协议，例如「报文至少有 8 字节」仍应由代码先检查。

空视图是正常值。Span<T>.Empty、default(Span<T>) 以及长度为零的切片都可用 IsEmpty 检查；不要把空视图自动解释为失败，除非 API 契约明确这样规定。

可写性与来源分开

视图的类型决定当前调用方能否写入，来源决定数据是否可能由其他路径改变。ReadOnlySpan<char> 指向字符串时，字符串自身不可变；同一类型指向数组时，数组所有者仍可修改元素。这两个事实不能只从参数类型中合并推断。

Span<T> 可以隐式转换为 ReadOnlySpan<T>，Memory<T> 也可以转换为 ReadOnlyMemory<T>。反向转换不存在，因为它会凭空增加写权限。需要可写访问时，应让所有者明确提供可写视图。

ref struct 限制逃逸

Span<T> 和 ReadOnlySpan<T> 是 ref struct，编译器用引用安全分析阻止视图逃出底层存储的有效范围。例如，指向当前方法 stackalloc 区域的 span 不能返回给调用方，也不能装箱为 object。

普通类不能保存 span 字段，lambda 也不能捕获 span，因为这些对象可能比当前栈帧活得更久。需要保存区域时，保存数组、字符串、Memory<T> 或拥有该区域的对象，并在每次同步访问时重新取得 .Span。

C# 13 起放宽了部分规则，C# 14 延续这些能力：ref struct 可以出现在异步或迭代器方法中，但所有使用都必须局限在不含 await 或 yield 的代码块内；它也能用于带 allows ref struct 反约束的泛型。旧文章中的「span 绝不能出现在 async 方法」已经不准确，但把它保留到暂停点之后仍不合法。

Memory<T> 穿过异步边界

异步方法应让 Memory<T> 穿过暂停点，再把同步处理放进接收 Span<T> 的辅助方法。这样，编译器看到的 span 生命周期只覆盖一次不会暂停的调用，而可存储的 memory 负责描述之后仍需访问的区域。

这并不延长底层所有者的寿命。若 Memory<T> 来自 IMemoryOwner<T>，所有者必须保持未释放状态；若来自 ArrayPool<T> 租出的数组，数组在所有消费者完成之前不能归还。返回一个指向已归还数组的 Memory<T> 是生命周期错误，不是类型系统能自动拦住的错误。

异步 API 还要区分容量与有效数据长度。池可能给出比请求更大的缓冲区，I/O 操作也可能只填充前一部分；应把 memory[..written] 传给消费者，而不是暴露整段容量。

所有权是额外契约

Microsoft 的使用指南把内存管理看作所有者、消费者与租期。所有者负责最终释放或归还存储，消费者在租期内读取或写入，租期规定视图何时仍有效。这三个角色可以由同一方法承担，也可以跨组件分开。

接受 Memory<T> 的方法不应默认获得释放权。除非 API 明确转移所有权，否则参数仍由调用方拥有；被调用方只能在约定期间借用。与流类似，是否释放不能靠类型名猜测。

公开 API 若要在返回后继续持有调用方内存，需要明确说明保留行为。调用方若无法保证生命周期，可先复制到自己拥有的数组；这次复制是有意建立所有权边界，而不是 span 使用失败。

示例

下面三个例子依次展示数组别名、无子字符串解析，以及跨异步边界保存 Memory<T>。本地环境没有 .NET SDK 或 C# 编译器，因此每个代码块都带有仓库约定的未执行标记，没有伪造控制台输出。

修改数组切片

数组切片仍与原数组共享元素。排序只发生在三元素视图范围内，但结果直接出现在原数组中。

ToArray() 只用于把当前视图交给 string.Join 并显示；它会创建副本，不属于切片本身。业务代码若只需遍历或传给另一个 span API，就不应为了方便而先物化。

把 window 声明为 ReadOnlySpan<int> 会阻止 window[0] = 20 和 Sort()，但不会隔离 readings。原数组仍是可写所有者。

解析字符片段

解析器先定位冒号，再把左右两段直接交给 int.TryParse(ReadOnlySpan<char>, ...)。失败路径把两个输出重置为零，调用方不会收到半解析结果。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;

foreach (string record in new[] { "17:245", "bad", "8:x" })
{
    bool ok = TryParseReading(record.AsSpan(), out int sensorId, out int value);
    Console.WriteLine($"{record} -> {ok}, {sensorId}, {value}");
}

static bool TryParseReading(
    ReadOnlySpan<char> record,
    out int sensorId,
    out int value)
{
    int separator = record.IndexOf(':');
    if (separator <= 0 || separator == record.Length - 1)
    {
        sensorId = 0;
        value = 0;
        return false;
    }

    bool idOk = int.TryParse(record[..separator], out sensorId);
    bool valueOk = int.TryParse(record[(separator + 1)..], out value);
    return idOk && valueOk;
}

# not executed here: the .NET SDK and C# compilers are unavailable

这里没有调用 Substring()。输入字符串仍然拥有字符，两个切片只在 TryParseReading 的同步调用中存在；方法返回后也没有保存任何视图。

真实协议通常还要规定空白、符号、数值范围和多余分隔符。span 只避免不需要的中间副本，不会替你定义这些输入规则。

在异步方法中保存 Memory<T>

Memory<byte> 可以在 await 前取得并在之后继续使用。实际修改交给同步辅助方法，避免任何 Span<byte> 跨越暂停点。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;
using System.Text;
using System.Threading.Tasks;

byte[] payload = Encoding.ASCII.GetBytes("aBc-19");
await NormalizeAsciiAsync(payload.AsMemory());
Console.WriteLine(Encoding.ASCII.GetString(payload));

static async Task NormalizeAsciiAsync(Memory<byte> payload)
{
    await Task.Yield();
    NormalizeAscii(payload.Span);
}

static void NormalizeAscii(Span<byte> bytes)
{
    for (int index = 0; index < bytes.Length; index++)
    {
        byte current = bytes[index];
        if (current is >= (byte)'A' and <= (byte)'Z')
        {
            bytes[index] = (byte)(current + ('a' - 'A'));
        }
    }
}

# not executed here: the .NET SDK and C# compilers are unavailable

数组由调用方拥有，所以在任务完成后仍有效，修改也能从 payload 观察到。若方法只应读取数据，把两个参数分别改为 ReadOnlyMemory<byte> 和 ReadOnlySpan<byte>，让签名表达权限。

如果来源改为池化内存，调用方必须等待 NormalizeAsciiAsync 完成后才能归还缓冲区。仅仅把数组包装为 Memory<byte> 不会建立租期或引用计数。

为临时缓冲区设置边界

同一个同步算法可以在小输入时使用 stackalloc，在较大输入时租用数组。两条路径都产生 Span<byte>，所以求和逻辑不需要复制两份。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;
using System.Buffers;

byte[] small = [3, 1, 4, 1, 5];
byte[] large = new byte[80];
large.AsSpan().Fill(2);

Console.WriteLine(Checksum(small));
Console.WriteLine(Checksum(large));

static int Checksum(ReadOnlySpan<byte> source)
{
    const int StackLimit = 64; // 这是示例策略，不是通用阈值。
    byte[]? rented = null;

    try
    {
        Span<byte> scratch = source.Length <= StackLimit
            ? stackalloc byte[source.Length]
            : (rented = ArrayPool<byte>.Shared.Rent(source.Length))
                .AsSpan(0, source.Length);

        source.CopyTo(scratch);
        int checksum = 0;
        foreach (byte value in scratch)
        {
            checksum += value;
        }
        return checksum;
    }
    finally
    {
        if (rented is not null)
        {
            ArrayPool<byte>.Shared.Return(rented, clearArray: true);
        }
    }
}

# not executed here: the .NET SDK and C# compilers are unavailable

租出的数组可能大于 source.Length，因此代码立即切成准确的逻辑长度。finally 保证异常路径也归还数组；这里选择清除，是因为示例把临时内容视为不应泄漏给下一位租用者的数据。

StackLimit 只展示控制流，不是可移植的性能结论。生产代码应根据调用深度、输入上限和基准决定阈值；若复制本身没有业务需要，就应直接在 source 上计算，而不是为了使用 span 再造缓冲区。

陷阱

把切片当成副本

修复方法： 需要独立数据时显式调用 ToArray()，并把复制写进变量名或 API 文档。只需要借用时保留视图，同时测试对切片的写入是否应反映到所有者。

把只读视图当成不可变数据

修复方法： 若消费者需要稳定快照，就复制到自己拥有的存储；若允许共享变化，则在契约中说明。不要用 ReadOnlyMemory<T> 代替所有权和并发同步设计。

让 span 逃出安全范围

修复方法： 保存所有者或 Memory<T>，在紧邻同步使用的位置取得 .Span。异步方法中即使某个局部写法能编译，也要确认 span 在任何暂停点都不再存活。

返回已经归还或释放的内存

修复方法： 要么在所有者作用域内完成消费，要么把所有者连同内存一起转交，并明确由谁释放。若 API 只返回数据且不能表达租期，就返回调用方拥有的副本。

对不受限长度使用 stackalloc

修复方法： 设定经过评审的小型上限，超出时改用数组或池，并在读取前初始化所需区域。阈值应由真实调用深度与测试决定，不能照抄一个通用常数。

延伸阅读

• Memory<T> 与 Span<T> 使用指南
• Span<T> API
• Memory<T> API
• ref struct 类型
• stackalloc 表达式
• C# 14 新增功能