【C# IO 操作】Span<T>类\Memory<T>

简介

System.Span<T>\System.ReadOnlySpan<T>、System.Memory<T> \System.ReadOnlyMemory<T>及其对应的只读类型被设计为:

Memory<T>视为Span<T>的工厂,和Span<T>一样，通常Memory<T>都是包裹数组、字符串，用法也基本相同，只是应用场景不一样而已。
避免不必要地复制内存或在托管堆上进行内存分配
通过 Slice 方法或这些类型的的构造函数创建它们, 并不涉及复制底层缓冲(underlying buffers): 只更新相关引用和偏移
- 形象的说就是，只更新我们可以访问到的内存的位置和范围，而不是将这些内存数据复制出来

应用场景：

1、序列化中的Utf8JsonReader>ReadOnlySequence<T> >System.Memory<T>

2、Span<T> string、数组、list<T> 中复制，

3、一般Span<T>由底层开发人员用在数据同步处理和转换方面，而高层开发人员使用Memory<T>比较多，因为它可以用于一些高级的场景，比如：异步方法、类字段、lambda表达式、泛型参数等等。两者的完美运用就能够支持无复制流动数据，这就是数据管道应用场景(System.IO.Pipelines)。

Span<T> 原理探究

ref结构

ref struct是仅在堆栈上的值类型：

表现一个顺序结构的布局；（译注：可以理解为连续内存）
只能在堆栈上使用。即用作方法参数和局部变量；
不能是类或正常结构的静态或实例成员；
不能是异步方法或lambda表达式的方法参数；
不能动态绑定、装箱、拆箱、包装或转换。

ref struct也被称为嵌入式引用。

1. Span 源码分析

灵活运用 Span 解决工作中的实际问题我相信大家应该没什么毛病了，有了这个基础再从 Span 的源码和用户态和大家一起深度剖析，从源码开始吧。


    public readonly ref struct Span<T>
    {
        internal readonly ByReference<T> _pointer;

        private readonly int _length;
    }

上面代码的 ref struct 可以看出，这个 Span 是只可以分配在栈上的值类型，然后就是里面的 _pointer 和 _length 两个实例字段，不知道看完这两个字段脑子里是不是有一幅图，大概是这样的。

可以清晰的看出，Span 就是用来映射一段可以连续访问的内存地址，空间大小由 length 控制，开始位置由 _pointer 指定，是不是像极了指针😁😁😁，是的，语言团队要保证你的程序高性能，还得照护你的人身安全，出了各种手段，真是煞费苦心！ 👍👍👍

二、Span<T>常规用法

    static void Main()
    {

      var nums = new int[] { 1, 2, 3, 4, 5, 6,8,9,7,10,11,12,13,14,15,16 };
        //用数组来实例化span
      var span = new Span<int>(nums);

      var Slice1 = span.Slice(1, 4);//2 3 4 5
      var Slice2= span.Slice(10);// 11,12,13,14,15,16
      var Slice3=  Slice1.ToArray();//转化成数组
      var Slice4 = new Span<int>(new int[Slice1.Length]);//新建一个span,长度不能小于slice1 要不会报错
        Slice1.CopyTo(sp);
        foreach (var item in Slice2)
        {
            Console.WriteLine($"{item}");
        }

    }

三：Span 在 String 和 List 的实践

Span的应用场景真的是太多了，不可能在这篇一一列举，这里我就举两个例子吧，让大家能够感受到 Span 的强大即可。

1. 在 String 上的应用

案例：如何高效的计算出用户输入的值 10+20 ?

1) 传统 Substring 做法

传统的做法很简单,截取呗，代码如下：


        static void Main(string[] args)
        {
            var word = "10+20";

            var splitIndex = word.IndexOf("+");

            var num1 = int.Parse(word.Substring(0, splitIndex));

            var num2 = int.Parse(word.Substring(splitIndex + 1));

            var sum = num1 + num2;

            Console.WriteLine($"{num1}+{num2}={sum}");

            Console.ReadLine();
        }

结果是很轻松的算出来了，但你仔细想想这里是不是有点什么问题，比如说为了从 word 中扣出 num，我用了两次 SubString，就意味着会在托管堆上生成两个 string，如果说我执行 1w 次话，那托管堆上会不会有 2w 个 string 呢？修改代码如下：


            for (int i = 0; i < 10000; i++)
            {
                var num1 = int.Parse(word.Substring(0, splitIndex));

                var num2 = int.Parse(word.Substring(splitIndex + 1));

                var sum = num1 + num2; 
            }

然后看一下托管堆上 String 的个数


0:000> !dumpheap -type String -stat
Statistics:
              MT    Count    TotalSize Class Name
00007ffc53a81e18    20167       556538 System.String

托管堆上有 20167 个，挺恐怖的，真的是给 GC 添麻烦哈，这里还有 167 个是系统自带的，接下来的问题是有没有办法替换 SubString 从而不生成临时string呢？

2) 新式 Span 做法

如果看懂了 Span 结构图，你就应该会使用 _pointer + length 将 string 进行切片处理，对不对，代码如下：


            for (int i = 0; i < 10000; i++)
            {
                var num1 = int.Parse(word.AsSpan(0, splitIndex));

                var num2 = int.Parse(word.AsSpan(splitIndex));

                var sum = num1 + num2; 
            }

然后在托管堆验证一下，是不是没有临时 string 了？


0:000> !dumpheap -type String -stat
Statistics:
              MT    Count    TotalSize Class Name
00007ffc53a51e18      167        36538 System.String

可以看到就只有 167 个系统字符串，性能也得到了不小的提升，🐂👃🦆。

2. 在 List 上的应用

平时用 Span 的时候，更多的会应用到 Array 上面，毕竟 Array 在托管堆上是连续内存，方便 Span 在上面画一个可视窗口，其实不仅仅是 Array，从 .NET5 开始在 List 上画一个视图也是可以的，截图如下：

因为 List 的 CURD 会导致底层的 Array 忽长忽短或重新分配，也就无法实现物理上的连续内存，所以 Span 应用到 List 之后，希望List是不可变的，这也是官方的建议。

3、span的局限性

span只能存储到执行栈上，保障操作效率与数组一样高，并提供稳定的生命周期。
span不能被装箱到堆上，避免栈撕裂问题。
span不能用作泛型类型参数。
Span不能作为类的字段。
Span不能实现任何接口。
Span不能用于异步方法，因为无法跨越await边界，所有无法跨异步操作暂留。

下面来看一个例子：

async Task DoSomethingAsync(Span<byte> buffer) {// 这里编译器会提示报错，作为例子而已，请忽略。
    buffer[0] = 0;
    await Something(); // 异步方法会释放当前执行栈，那么Span也被回收了。
    buffer[0] = 1; // 这里buffer将无法继续。
}

备注：C#编译器和core运行时内部会强制验证Span的局限性，所以上面例子才会编译不过。

正是因为这些局限性，确保了更高效、安全的内存访问。

也是因为这些局限性，无法用于需要将引用数据存储到堆上的一些高级应用场景，比如：异步方法、类字段、泛型参数、集合成员、lambda表达式、迭代器等。

还是因为这些局限性，增加了span对于高层开发人员的复杂性。

所以Memory<T>诞生了，作为span的补充，它就是目前的解决方案，没有之一，也是高层开发人员日后使用最普遍的类型。

Memory<T>

what - memory是什么 ?

和Span<T>一样，也是sliceable type ，但它不是ref-like type ，就是普通的C#结构体。这意味着，可以将它装箱到堆上、作为类的字段或异步方法的参数、保存到集合等等，对于高层开发人员非常友好，嘿嘿，并且当需要处理Memory底层缓冲区，即做同步处理时，直接调用它的Span属性，同时又获得了高效的索引能力。

备注：Memory<T>表示一段可读写的连续内存区域，ReadOnlyMemory表示一段只读的连续内存区域。

static async Task<uint> ChecksumReadAsync(Memory<byte> buffer, Stream stream)
{
    var bytesRead = await stream.ReadAsync(buffer);
    // 需要同步处理时，直接调用span属性。
    return SafeSum(buffer.Span.Slice(0, bytesRead));
    // 千万不要这样写，除非你想要先持久化分片数据到托管堆上，但这又无法使用Span<T>实现；其次Memory <T>是一个比Span<T>更大的结构体，切片往往相对较慢。
    //return SafeSum(buffer.Slice(0,bytesRead).Span());
}
static uint SafeSum(Span<byte> buffer)
{
    uint sum = 0;
    foreach (var t in buffer)
    {
        sum += t;
    }
    return sum;
}

Memory核心设计

public readonly struct Memory<T>
{
    private readonly object _object; //表示Memory能包裹的对象，EveryThing。
    private readonly int _index;
    private readonly int _length; 
    public Span<T> Span { get; } // 实际的内部缓冲区
}

如前所述，Memory的目的是为了解决Span无法驻留到堆上的问题，也就是Memory代表的内存块并不会随方法执行栈的unwind而回收，也就是说它的内部缓冲区是有生命周期的，并不是短暂的，这就是为什么字段_object的类型被设计成object，而不是类型化为T[]，就是为了通过传递IMemoryOwner来管理Span的生命周期，从而避免UAF（use-after-free）bug。

private static MemoryPool<byte> _memPool = MemoryPool<byte>.Shared;

public async Task UsageWithLifeAsync(int size)
{
    using (var owner = _memPool.Rent(size)) // 从池里租借一块IMemoryOwner包裹的内存。
    {
        await DoSomethingAsync(owner.Memory); // 把实际的内存借给异步方法使用。
    } // 作用域结束，存储的Memory<T>被回收，这里是返还给内存池，有借有还，再借不难，嘿嘿。
}
// 不用担心span会随着方法执行栈unwind而回收
async Task DoSomethingAsync(Memory<byte> buffer) {
    buffer.Span[0] = 0; // 没问题
    await Something(); // 跨越await边界。
    buffer.Span[0] = 1; // 没问题
}

IMemoryOwner，顾名思义，Memory<T>拥有者，通过属性Memory来表示，如下：

public interface IMemoryOwner<T> : IDisposable
{
    Memory<T> Memory { get; }
}

所以，可以使用IMemoryOwner来转移Memory<T>内部缓冲区的所有权，从而让开发人员不必管理缓冲区。

关于如何优雅地管理Memory<T>内部缓冲区的生命周期，在设计时工程师们考虑过好几种方案，比如：联合标识、自动引用计数(ARC)等，但最后还是选择上面这种方案，即通过实现IMemoryOwner间接地重新获得Memory<T>内部缓冲区的控制权，其实每次都是创建一个新的Span，所以可以将Memory<T>视为Span<T>的工厂。

How - 如何运用memory ?

如前所述， Memory<T>其实就是Span<T>的heap-able类型，故它的API和span基本相同，如下：

public Memory(T[] array);
public Memory(T[] array, int start, int length);
public Memory<T> Slice(int start);// 支持sliceable
public bool TryCopyTo(Memory<T> destination);

不同的是Memory<T>有两个独一无二的API，如下：

public MemoryHandle Pin(); // 钉住_object的内存地址，即告知垃圾回收器不要回收它，我们自己管理内存。
public System.Span<T> Span { get; }// 当_object字段为数组时，提供快速索引的能力。

和Span<T>一样，通常Memory<T>都是包裹数组、字符串，用法也基本相同，只是应用场景不一样而已。

Memory<T>的使用指南：

同步方法应该接受Span参数，异步方法应该接受Memory参数。
以Memory<T>作为参数无返回值的同步方法，方法结束后，不应该再使用它。
以Memory<T>作为参数返回Task的异步方法，方法结束后，不应该再使用它。
同一Memory<T>实例不能同时被多个消费者使用。

所以啊，千万不要将好东西用错地方了，聪明反被聪明误，最后，弄巧成拙，嘿嘿。

四：总结

总的来说，Span 在 .NET 底层框架中的地位是越来越显著了，相信 netCore 追求更高更快的性能上 Span 一定大有可为，大家赶紧学起来，😀😀😀

原文链接：https://www.cnblogs.com/huangxincheng/p/13974476.html

posted @ 2021-11-12 21:59 小林野夫阅读(466) 评论(0) 编辑收藏举报

刷新页面返回顶部

小林野夫

C#编程学习记录

【C# IO 操作】Span<T>类\Memory<T>

简介

应用场景：

Span<T> 原理探究

1. Span 源码分析

二、Span<T>常规用法

三：Span 在 String 和 List 的实践

1. 在 String 上的应用

1) 传统 Substring 做法

2) 新式 Span 做法

2. 在 List 上的应用

3、span的局限性

Memory<T>

what - memory是什么 ?

Memory核心设计

How - 如何运用memory ?

四：总结

公告

小林野夫

C#编程学习记录

【C# IO 操作 】Span<T>类\Memory<T>

简介

应用场景：

Span<T> 原理探究

1. Span 源码分析

二、Span<T>常规用法

三：Span 在 String 和 List 的实践

1. 在 String 上的应用

1) 传统 Substring 做法

2) 新式 Span 做法

2. 在 List 上的应用

3、span的局限性

Memory<T>

what - memory是什么 ?

Memory核心设计

How - 如何运用memory ?

四：总结

公告

【C# IO 操作】Span<T>类\Memory<T>