C#7.2中Span <T>和Memory <T>有什么区别？

Question

C#7.2引入了两个新类型:Span<T>并Memory<T>有超过早先C#类型,如更好的性能string[].

问题:Span<T>和之间有什么区别Memory<T>？为什么我会使用一个而不是另一个？

Answer 1

Span<T>堆栈只能在堆栈中Memory<T>存在.

Span<T>是我们添加到平台的新类型,用于表示任意内存的连续区域,其性能特征与T []相同.它的API类似于数组,但与数组不同,它可以指向托管或本机内存,也可以指向堆栈上分配的内存.

Memory <T>是一种类型的补充Span<T>.如其设计文档中所讨论的,Span<T>是仅堆栈类型.仅堆栈特性 Span<T>使其不适用于需要Span<T>在堆上存储对缓冲区(用...表示)的引用的许多场景,例如对于执行异步调用的例程.

async Task DoSomethingAsync(Span<byte> buffer) {
    buffer[0] = 0;
    await Something(); // Oops! The stack unwinds here, but the buffer below
                       // cannot survive the continuation.
    buffer[0] = 1;
}

为了解决这个问题,我们将提供一组互补类型,旨在用作通用交换类型,就像Span <T>一系列任意内存一样,但不像Span <T> 这些类型不会只是堆栈,代价是重要的阅读和写入内存的性能惩罚.

async Task DoSomethingAsync(Memory<byte> buffer) {
    buffer.Span[0] = 0;
    await Something(); // The stack unwinds here, but it's OK as Memory<T> is
                       // just like any other type.
    buffer.Span[0] = 1;
}

在上面的示例中,Memory <byte>用于表示缓冲区.它是常规类型,可用于执行异步调用的方法.它的Span属性返回Span<byte>,但在异步调用期间返回的值不会存储在堆上,而是从该Memory<T>值生成新值.从某种意义上说, Memory<T>是一个工厂Span<T>.

参考文件:这里

Answer 2

re:这意味着它只能指向堆栈上分配的内存.

Span<T>可以指向任何内存:在堆栈或堆上分配.仅堆栈特性Span<T>意味着它Span<T>本身(而不是它指向的内存)必须只驻留在堆栈上.这与"普通"C#结构形成对比,后者可以驻留在堆栈上或堆上(通过值类型装箱,或者当它们嵌入在类/引用类型中时).一些更明显的实际意义是你不能Span<T>在一个类中有一个字段,你不能包含它Span<T>,你不能创建它们的数组.

Answer 3

一般的

Span 定义为引用结构 ，Memory定义为结构

这是什么意思？

• 引用结构不能存储在堆上，编译器将阻止您这样做，因此不允许以下操作：

  • 使用Span作为类中的字段
  • 在异步方法中使用Span（异步方法正在成熟的状态机中扩展）
  • 还有更多，这里是无法使用引用结构完成的事情的完整列表。

• stackalloc不适用于Memory（因为不能保证它不会存储在堆上），但适用于Span

  // this is legit
  Span<byte> data = stackalloc byte[256]; // legit
  
  // compile time error: Conversion of a stackalloc expression of type 'byte' to type 'Memory<byte>' is not possible.
  Memory<byte> data = stackalloc byte[256];
  

这意味着什么？

这意味着在某些情况下， Span本身无法进行各种微优化，因此应使用内存。

例子：

下面是一个字符串分配自由Split方法的示例，该方法适用于ReadOnlyMemory结构，在Span上实现此方法非常困难，因为Span是一个引用结构，不能放入数组或IEnumerable中：

（实现摘自《C# in a nutshell 》一 书）

IEnumerable<ReadOnlyMemory<char>> Split(ReadOnlyMemory<char> input)
{
    int wordStart = 0;
    for (int i = 0; i <= input.Length; i++)
    {
        if (i == input.Length || char.IsWhiteSpace(input.Span[i]))
        {
            yield return input.Slice(wordStart, i - wordStart);
            wordStart = i + 1;
        }
    }
}

以下是在 .NET SDK=6.0.403 上通过dotnet 基准测试库针对常规Split方法进行的非常简单的基准测试的结果。

|                Method |     StringUnderTest |              Mean |             Error |            StdDev |      Gen0 |      Gen1 |     Gen2 |  Allocated |
|---------------------- |-------------------- |------------------:|------------------:|------------------:|----------:|----------:|---------:|-----------:|
|          RegularSplit |                meow |         13.194 ns |         0.2891 ns |         0.3656 ns |    0.0051 |         - |        - |       32 B |
| SplitOnReadOnlyMemory |                meow |          8.991 ns |         0.1981 ns |         0.2433 ns |    0.0127 |         - |        - |       80 B |
|          RegularSplit | meow(...)meow [499] |      1,077.807 ns |        21.2291 ns |        34.8801 ns |    0.6409 |    0.0095 |        - |     4024 B |
| SplitOnReadOnlyMemory | meow(...)meow [499] |          9.036 ns |         0.2055 ns |         0.2366 ns |    0.0127 |         - |        - |       80 B |
|          RegularSplit | meo(...)eow [49999] |    121,740.719 ns |     2,221.3079 ns |     2,077.8128 ns |   63.4766 |   18.5547 |        - |   400024 B |
| SplitOnReadOnlyMemory | meo(...)eow [49999] |          9.048 ns |         0.2033 ns |         0.2782 ns |    0.0127 |         - |        - |       80 B |
|          RegularSplit | me(...)ow [4999999] | 67,502,918.403 ns | 1,252,689.2949 ns | 2,092,962.4006 ns | 5625.0000 | 2375.0000 | 750.0000 | 40000642 B |
| SplitOnReadOnlyMemory | me(...)ow [4999999] |          9.160 ns |         0.2057 ns |         0.2286 ns |    0.0127 |         - |        - |       80 B |

这些方法的输入是“meow”字符串重复 1、100、10_000 和 1_000_000 次，我的基准设置并不理想，但它显示了差异。