如何简便获取Memory<byte>/Span<byte>对应的可变结构体？

Great question! Let's dig into your options for zero-copy struct access on byte buffers without relying on unsafe code.

Your Current Approach is Already Idiomatic #

First off, the method you're using with MemoryMarshal.Cast<byte, Data> is actually one of the cleanest, safest ways to achieve this. It reinterprets the underlying byte span as a span of your struct type, and using ref ensures you modify the original buffer directly (no copies involved). Let's recap the working example for clarity:

public struct Data
{
    public int Id;
    public float Value;
}

// Example usage
var buffer = new byte[sizeof(Data)];
var dataSpan = MemoryMarshal.Cast<byte, Data>(buffer.AsSpan());
ref Data dataRef = ref dataSpan[0];

// Modify directly in the buffer
dataRef.Id = 123;
dataRef.Value = 45.6f;

This is the go-to pattern for zero-copy struct access in modern C#—it's type-safe, doesn't require unsafe, and gets the job done efficiently.

Alternatives (With Tradeoffs) #

If you're looking for slight variations or more expressive syntax, here are a couple of options:

1. Shorthand with MemoryMarshal.GetReference #

You can skip creating a full Span<Data> and get a direct ref to the struct in one line:

ref Data dataRef = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<byte, Data>(buffer.AsSpan()));

This is a minor simplification if you only need access to a single struct instance, but it's essentially just a condensed version of your original code.

2. Custom Ref Struct Wrapper #

For more readable, reusable code, you can create a ref struct that wraps the byte buffer and exposes the struct via a ref property. This avoids repeating the MemoryMarshal.Cast call everywhere:

using System.Diagnostics;

public ref struct DataBuffer
{
    private readonly Span<byte> _buffer;

    public DataBuffer(Span<byte> buffer)
    {
        Debug.Assert(buffer.Length >= sizeof(Data), "Buffer too small for Data struct");
        _buffer = buffer;
    }

    public ref Data Value => ref MemoryMarshal.GetReference(MemoryMarshal.Cast<byte, Data>(_buffer));
}

// Usage
var buffer = new byte[sizeof(Data)];
var dataBuffer = new DataBuffer(buffer.AsSpan());

dataBuffer.Value.Id = 123;
dataBuffer.Value.Value = 45.6f;

This makes your code more expressive, but keep in mind that ref structs can't be used as generic type arguments (as you discovered), so this won't work if you need to pass the wrapper to generic methods.

Avoiding the Copy Pitfall #

You mentioned encountering cases where modifications don't reflect back to the buffer—this almost always happens when you access the struct directly without ref, which creates a copy:

// ❌ This creates a copy! Changes won't affect the original buffer.
Data dataCopy = dataSpan[0];
dataCopy.Id = 123;

Always use ref when accessing the struct from the span to ensure you're working with the original memory.

Why There's No "Even Simpler" Built-In Method #

C# prioritizes type safety, so reinterpreting bytes as a struct is an explicit operation that requires using MemoryMarshal to signal your intent. There's no magic AsStruct<T> method because that would hide the low-level nature of the operation.

Your original approach is already the most straightforward, idiomatic way to do this without unsafe code. The alternatives either are minor shorthands or require extra boilerplate, but they don't offer a huge simplification over what you're already using.

内容的提问来源于stack exchange，提问作者mycroes