.NET 的 Span<T> 类型

.NET core 从 2.1（C# 7.3）开始就引入了 Span<T> 类型。Span<T> 是一个 ref struct。

Span<T> 是轻量级内存缓冲区访问类型，它封装了托管或非托管内存的引用。

使用 Span<T> 可以避免不必要的内存拷贝，比传统数组操作更高效。

ReadOnlySpan<T> 是 Span<T> 的只读版本。当堆缓冲区仅需要只读访问时，应该使用 ReadOnlySpan<T>。

Span<T> 的内部实现

下面是在 github.com上dotnet/runtime 上面的官方源码片段。 访问时间为写本文的时间。

//github.com 上 Span.cs 源码（某个版本）
public readonly ref struct Span<T>
{
    // A byref or a native ptr.
    internal readonly ref T _reference;

    // The number of elements
    // this Span contains.
    private readonly int _length;

    public ref T this[int index]
    {
        [Intrinsic]
        [MethodImpl(
            MethodImplOptions.AggressiveInlining)]
        [NonVersionable]
        get
        {
            if ((uint)index >= (uint)_length)
                ThrowHelper
                .ThrowIndexOutOfRangeException();
            return ref Unsafe.Add(ref _reference, 
                (nint)(uint)index 
                /* force zero-extension */);
        }
    }

    // 其它代码 ...
}

可以看出，Span<T> 是一个轻量级的 ref struct。

索引器返回元素的引用。

Span<T> 的成员

构造方法：

Span<T>(T[]? array) 从数组创建 Span<T> 对象。

Span<T> (T[]? array, int start, int length) 从数组的一部分范围创建 Span<T> 对象。

...，等等。

属性：

bool IsEmpty { get; } 判断是否为空。

ref T this[int index] { get; } 根据下标访问元素。

int Length { get; } 返回元素个数。

...，等等。

方法：

void CopyTo(Span<T> destination); 把元素拷贝到另一个 Span<T>。

Span Slice(int start, int length); 返回一个 Span<T>，包含 Span<T> 当前的一个切边。

T[] ToArray(); 返回一个数组，包含当前Span<T>的元素。

...，等等。

Span<T> 与之前无 Span<T> 的对比

比如，要从一行文本读取两个整数。

在 Span<T>之前，很容易得到的就是，使用 string.Substring() 来分离字符串。

请看下面这段代码：

string input = "123,456";
int commaPos = input.IndexOf(',');
int first = int.Parse(
    input.Substring(0, commaPos));
int second = int.Parse(
    input.Substring(commaPos + 1));

这里，string.Substring() 返回 string，即生成一个新的 string 实例， 包含一个托管堆（heap）的分配和字符串拷贝这样的动作（尽管在这里的数据量并不大）。

在这段代码完成以后，新生成的两个string实例将被（标志）垃圾回收。

这些本可以避免的内存申请、拷贝和释放操作，在频繁调用的场景，比如 web 服务器中，会带来不可忽略的性能损耗。

有了 Span<T>之后，我们可以这样操作：

string input = "123,456";
ReadOnlySpan<char> inputSpan 
    = input.AsSpan();
// AsSpan 是 string 的扩展方法
// 返回 ReadOnlySpan<char>
int commaPos = input.IndexOf(',');
int first = int.Parse(
    inputSpan.Slice(0, commaPos));
int second = int.Parse(
    inputSpan.Slice(commaPos + 1));

AsSpan() 是 string 的扩展方法，返回 ReadOnlySpan<char>。

ReadOnlySpan<char> 是 ref struct，它是在栈（stack）上分配的。分配和释放基本是指针加减操作，没有性能负担。 而且，这里没有字符串拷贝操作，ReadOnlySpan<char> 只存放一个引用字段和一个长度字段。

同样地，inputSpan.Slice() 返回 ReadOnlySpan<char>。这里也没有托管堆（heap）的分配和字符串拷贝操作。

由此可见，使用 Span<T> 能避免不必要的性能开销。 它通过引用来操作内存缓冲区，类似 C 语言使用指针那样高效。同时它还具有访问越界保护，避免缓冲区溢出的问题。

Span<T> 的操作演示

Span<T> 可以操作托管内存、本地（native）内存以及栈内存。

下面代码片段，分别对这 3 种内存进行操作演示。

public static void WorkWithSpans()
{// 分别使用托管数组、本地缓冲区、栈内缓冲区
    // 创建Span<byte>,做相同的测试
    int size = 100;

    Span_Array(size);
    Span_Native(size);
    Span_Stack(size);
}

private static void Span_Array(int size)
{
    // 从托管数组创建 Span
    byte[] array = new byte[size];
    Span<byte> arraySpan = new(array);

    DoSpanWork(arraySpan);
}

private static void Span_Native(int size)
{
    // 从本地内存块创建 Span
    var native = Marshal.AllocHGlobal(size);
    Span<byte> nativeSpan;
    unsafe
    {// 用到不安全（unsafe）代码块
    // 需要编译器参数 AllowUnsafeBlocks 为 true
        nativeSpan = new Span<byte>(
            native.ToPointer(), size);
    }

    DoSpanWork(nativeSpan);

    // 分配的本地内存块，需要自己释放
    Marshal.FreeHGlobal(native);
}

private static void Span_Stack(int size)
{
    // 在栈内申请内存块，创建 Span
    Span<byte> stackSpan = 
        stackalloc byte[size];

    DoSpanWork(stackSpan);
}

private static void DoSpanWork(
    Span<byte> span)
{// 给Span设置元素值，然后计算总和
    InitializeSpan(span);
    Console.WriteLine(
        $"The sum is {
            ComputeSum(span):N0}");
}

private static void InitializeSpan(
    Span<byte> span)
{// Span 内设置每个元素的值
    byte value = 0;
    for (int ctr = 0; 
        ctr < span.Length; ctr++)
        span[ctr] = value++;
}

private static int ComputeSum(
    ReadOnlySpan<byte> span)
{// 计算总和
    int sum = 0;
    foreach (byte value in span)
        sum += value;

    return sum;
}

// 调用WorkWithSpans()，输出结果：
//    The sum is 4,950
//    The sum is 4,950
//    The sum is 4,950

Span<T> 的限制

Span<T> 类型是 ref struct，它在栈（stack）上分配，而不是在托管堆（managed heap）上。

因为在堆上分配，而且是 ref 的，导致对它的使用受到一些限制。

限制包括：不能装箱（boxed），不能赋值给 Object、dynamic 和接口类型， 不能跨越await 和 yield 的边界，不能调用 Equals(Object) 和 GetHashCode() 方法。

这些，编译器都会帮你做检查。

在 Span<T> 不能使用的时候，可以考虑使用 Memory<T>。

Memory<T> 同样是轻量级内存缓冲区访问类型。它只是 struct 类型，可以封装转为 Object，没有 Span<T> 的限制。

Span<T> 的应用

为了支持 Span 及其成员，.NET 基于数组和基于字符串的方法都有相应的重载。另外还有一些专注于特定处理方面的类型。

例如，所有原始类型（如 Int32）都包含接受 ReadOnlySpan<char> 的 Parse 重载。

再如，System.Random、System.Text.StringBuilder、System.Net.Socket 也有重载轻松高效地处理 {ReadOnly}Span<T> 和 {ReadOnly}Memory<T>。

又如，ASP.NET Core 严重依赖 Span。

还有许多依赖 Span 的应用。

结束语

Span<T>是 .NET 中用于高性能内存操作的关键类型，它提供了许多优势并在多种场景下得到广泛应用， 是现代 .NET 高性能编程不可或缺的工具。