При отладке не видно данные расположенные в Span

Наверное дело в том, что buffer - это значимый тип, и когда отладчик пытается получить экземпляр, он фактически создает новый внутри себя с учетом полей данных и копирует все значимые типы. Но здесь за счет небезопасного кода используется область памяти, выделенная под структуру в LayoutKind, но не выделенная под данные.

Видимо отладчику от этого становится плохо и он просто не клонирует байты в свой новый экземпляр этой структуры, при чем если симотреть в само свойство, то данные есть, если же через инспектор смотреть в это же свойство, не упоминаемое в коде, то данных нет. Может быть, это баг студии, я до конца не понял.

В любом случае, в рантайме все прекрасно работает. Могу только сказать, что вы "слегка" перемудрили, но мысль верная, и мне понравился этот хоть и небезопасный, но подход.

Я решил немного упростить код

public class Program
{
    public static void Main()
    {
        MyMessage buffer = new();
        byte[] message = Encoding.UTF8.GetBytes("Привет, мир!");
        buffer.Data = message;
        buffer.Type = MessageType.HandShake;

        Console.WriteLine(Marshal.SizeOf<MyMessage>());
        Console.WriteLine(buffer.Type);
        ReadOnlySpan<byte> bytes = buffer;
        Console.WriteLine(bytes.Length);
        Console.WriteLine(Encoding.UTF8.GetString(buffer.Data));
        Console.WriteLine(Encoding.UTF8.GetString(bytes));
    }
}

public enum MessageType
    : uint
{
    Unknown,
    HandShake,
    Update,
    Status,
    Disconnect
}

[StructLayout(LayoutKind.Sequential, Size = size)]
public unsafe struct MyMessage
{
    public const int size = 2048;
    public const int dataOffset = sizeof(int) + sizeof(MessageType);

    public MessageType Type;
    private int _length;

    public ReadOnlySpan<byte> Data
    {
        get => GetSpan(dataOffset, _length);
        set
        {
            value.CopyTo(GetSpan(dataOffset, size - dataOffset));
            _length = value.Length;
        }
    }

    private ReadOnlySpan<byte> Bytes
    {
        get => GetSpan(0, _length + dataOffset);
        set => value.CopyTo(GetSpan(0, size));
    }

    private Span<byte> GetSpan(int offset, int length)
    {
        fixed (MyMessage* src = &this)
        {
            return new((byte*)src + offset, length);
        }
    }

    public ReadOnlySpan<byte> AsSpan() 
        => Bytes;

    public static implicit operator ReadOnlySpan<byte>(MyMessage buffer) 
        => buffer.Bytes;

    public static implicit operator MyMessage(ReadOnlySpan<byte> span) 
        => new() { Bytes = span };
}

UPD: Немного доработал, теперь длина спана, получаемого из неявного преобразования или через AsSpan() будет равна длине полезной нагрузки. Это чтобы можно было сразу слать спан в сеть "как есть". При этом поле _length содержит длину блока данных, что валидно для формата передачи данных, чтобы принимающий сервер смог прочитать данные так же в эту же структуру. То есть не обзязательно слать ровно 2 килобайта. Правда принимающей стороне придется все-таки смотреть в это поле, потом вычитывать данные согласно указанной длине и только потом закидывать их в структуру. Я думаю, здесь идея должна быто прозрачна. Если я конечно правильно понял назначение этого всего.

Отправить

myStream.Write(buffer);

Получить

byte[] bytes = new byte[2048];
myStream.Read(bytes, 0, 8);
int length = BitConverter.ToInt32(bytes, 4);
myStream.Read(bytes, 8, length);
MyMessage buffer = bytes;

Скриншот ниже относится к одной из прошлых версий кода, но я его не стал менять, потому что он свою суть показыват верно.

Вывод в консоль

2048
HandShake
29
Привет, мир!
☺§Привет, мир!

Если свойство Bytes сделать публичным, то можно увидеть следующее:

А вот так может выглядеть управляемая версия, я все-такие ее больше рекомендую, так как она не содержит ограничения в 2 килобайта. И занимает ровно столько памяти, сколько требуется для хранения данных.

public record MyMessage
{
    private const int headerSize = 8;
    private const int lengthOffset = 4;

    private readonly byte[] _bytes;
    public MessageType Type
    {
        get => (MessageType)BitConverter.ToUInt32(_bytes, 0);
        set => BitConverter.TryWriteBytes(_bytes, (uint)value);
    }

    public int Length => _bytes.Length;

    public ReadOnlySpan<byte> Data => _bytes.AsSpan(headerSize);

    public MyMessage(MessageType type, ReadOnlySpan<byte> data)
    {
        _bytes = new byte[data.Length + headerSize];
        data.CopyTo(_bytes.AsSpan(headerSize));
        Type = type;
        BitConverter.TryWriteBytes(_bytes.AsSpan(lengthOffset), data.Length);
    }

    private MyMessage(ReadOnlySpan<byte> bytes)
    {
        int length = BitConverter.ToInt32(bytes[lengthOffset..]);
        _bytes = new byte[length + headerSize];
        bytes[.._bytes.Length].CopyTo(_bytes);
    }

    public ReadOnlySpan<byte> AsSpan()
        => _bytes;

    public static implicit operator ReadOnlySpan<byte>(MyMessage message)
        => message._bytes;

    public static implicit operator MyMessage(ReadOnlySpan<byte> span)
        => new(span);
}

Я сделал ее немутабельной, поэтому тестовый код немного изменился

MyMessage message = new(MessageType.HandShake, Encoding.UTF8.GetBytes("Привет, мир!"));

Console.WriteLine(message);
ReadOnlySpan<byte> bytes = message;
Console.WriteLine(Encoding.UTF8.GetString(message.Data));
Console.WriteLine(Encoding.UTF8.GetString(bytes));

Вывод в консоль

MyMessage { Type = HandShake, Length = 29, Data = System.ReadOnlySpan<Byte>[21] }
Привет, мир!
☺§Привет, мир!

Приятный бонус record, у нее встроенный .ToString(), отображающий ее содержимое.

Можно добавить еще производительности с помощью ArrayPool<byte> и Buffer.BlockCopy, но код станет значительно сложнее, придется адаптироваться к тому, что ArrayPool выдает массив не точно того размера, который нужен, и реализовать IDisposable с финализатором, чтобы массив точно возвращался в пул, когда сообщение больше не нужно.