在结构上获取 Span<byte> 而无需复制结构

Question

我一直在试验 Span<T> 作为 ReadOnlySequence<T> 和 System.IO.Pipelines 的一部分。

我目前正在尝试在不使用 unsafe 代码且不复制 struct.

的情况下通过 struct 获得 Span<T>

我的结构很简单：

    [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
    public struct Packet
    {
        public byte TestByte;
    }

方法 1 - 有效 - 但感觉 "unsafe"

    //
    // Method 1 - uses Unsafe to get a span over the struct
    //
    var packet = new Packet();
    unsafe
    {
        var packetSpan = new Span<byte>(&packet, Marshal.SizeOf(packet));

        packetSpan[0] = 0xFF; // Set the test byte
        Debug.Assert(packet.TestByte == 0xFF, "Error, packetSpan did not update packet.");
            // ^^^ Succeeds
        packet.TestByte = 0xEE;
        Debug.Assert(packetSpan[0] == 0xEE, "Error, packet did not update packetSpan.");
            // ^^^ Succeeds
    }

方法 2 - 无法正常工作，因为它需要一份副本

    //
    // Method 2
    //
    // This doesn't work as intended because the original packet is actually
    // coppied to packet2Array because it's a value type
    //
    // Coppies the packet to an Array of Packets
    // Gets a Span<Packet> of the Array of Packets
    // Casts the Span<Packet> as a Span<byte>
    //
    var packet2 = new Packet();

    // create an array and store a copy of packet2 in it
    Packet[] packet2Array = new Packet[1];
    packet2Array[0] = packet2;

    // Get a Span<Packet> of the packet2Array
    Span<Packet> packet2SpanPacket = MemoryExtensions.AsSpan<Packet>(packet2Array);

    // Cast the Span<Packet> as a Span<byte>
    Span<byte> packet2Span = MemoryMarshal.Cast<Packet, byte>(packet2SpanPacket);

    packet2Span[0] = 0xFF; // Set the test byte
    Debug.Assert(packet2.TestByte == 0xFF, "Error, packet2Span did not update packet2");
        // ^^^ fails because packet2 was coppied into the array, and thus packet2 has not changed.
    Debug.Assert(packet2Array[0].TestByte == 0xFF, "Error, packet2Span did not update packet2Array[i]");
        // ^^^ succeeds

    packet2.TestByte = 0xEE;
    Debug.Assert(packet2Span[0] == 0xEE, "Error, packet2 did not update in packet2Span");
        // ^^^ fails because packet2Span is covering packet2Array which has a copy of packet2 
    packet2Array[0].TestByte = 0xEE;
    Debug.Assert(packet2Span[0] == 0xEE, "Error, packet2 did not update in packet2Span");
        // ^^^ succeeds

进一步的研究表明

Span<T> 可以从 byte[] 隐式转换，例如，我可以做

Span<byte> packetSpan = new Packet().ToByteArray();

但是我当前的任何 ToByteArray() 实现仍在制作 Packet 结构的副本。

我无法执行以下操作：

Span<byte> packetSpan = (byte[])packet;
    // ^^ Won't compile

Answer 1

在没有 unsafe 的情况下，无法通过任意结构获取 Span<byte>，因为这样的跨度将允许您以任何方式更改结构的任何位，可能会违反类型的不变量- 这本质上是一种不安全的操作。

好的，但是 ReadOnlySpan<byte> 呢？请注意，为了使代码合理，您必须将 StructLayoutAttribute 放在结构上。这应该是一个提示。想象一下尝试编写一个更简单的方法，一个 return 对任意 T where T : struct 的 byte[]。您必须先找出 struct 的大小，不是吗？那么，如何在 C# 中找出 struct 的大小？您可以使用 sizeof 运算符，它需要一个 unsafe 上下文并且需要结构是一个 unmanaged type; or you can Marshall.SizeOf 这是不稳定的并且仅适用于具有顺序或显式字节布局的结构。 没有安全、通用的方法，因此您不能那样做。

Span<T> 和 ReadOnlySpan<T> 在设计时并没有考虑访问结构字节，而是考虑了数组的跨越片段，这些片段具有已知的大小并保证是连续的。

如果您确信自己知道自己在做什么，则可以在 unsafe 上下文中执行此操作 - 这就是它的用途。但请注意，由于上述原因，您使用 unsafe 的解决方案不会推广到任意结构。

如果您打算将您的结构用作 IO 操作的缓冲区，您可能需要查看 fixed size buffers。它们还需要一个 unsafe 上下文，但您可以将不安全性封装在您的结构中，并将 return 和 Span<byte> 封装到该固定缓冲区。基本上任何处理内存中对象的字节结构的东西都需要 .NET 中的 unsafe，因为内存管理是这个 "safety" 所指的东西。

Answer 2

你必须在 unsafe context 中进行，因为根据这个词的真正含义 不安全 ，因为如果你不够小心，你会开枪自杀脚。原因如下：

考虑以下代码：

Span<byte> GiveMeSpan() 
{
    MyLovelyStruct value = new MyLovelyStruct();
    unsafe 
    {
        return new Span<byte>(&value, sizeof(MyLovelyStruct));
    }
}

我们在 GiveMeSpan() 中创建的 MyLovelyStruct 的实例存在于方法的 call stack and what your doing is taking its address, giving it to the Span<byte>, and returning the Span<byte>. Once a method returns it pops its stack frame 中，因此您的 MyLovelyStruct 所在的内存将变得空闲并且可能被调用者调用的下一个方法回收并破坏它。

但这还不是全部，如果您的 MyLovelyStruct 生活在这样的对象字段中怎么办：

class MyLovelyClass 
{
    private MyLovelyStruct value;

    public void Foo() 
    {
        unsafe 
        {
            var span = new Span(&value, sizeof(MyLovelyStruct));
            Process(span);
        }
    }
}

// Declaration 
Process(Span<byte> span);

还有一个GC happens when Process() method is processing your MyLovelyStruct and MyLovelyClass suddenly gets moved in the memory (Yes, GC move's objects in the memory, read here)？是的，您指向 MyLovelyStruct 的 Span<byte> 将不再指向新的 MyLovelyStruct 地址，并且您的程序会损坏。

因此，为了使用 Span<byte> 或任何其他指针类型安全地包装 struct，您必须确保：

实例位于固定的内存位置（例如在堆栈或非托管内存中，如 Marshal.AllocHGlobal 分配的内存块）
在您使用完指针之前不会申请实例内存

因此 unsafe 关键字是必需的，即使您可以绕过它，您也有责任警告阅读您代码的读者。

在结构上获取 Span<byte> 而无需复制结构

Obtain a Span<byte> over a struct without making a copy of the struct

c#

system.io.pipelines