Маршалинг структур: динамическое управление размером

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
        public struct Package
        {
            public byte pack_type;
            public byte con_status;
            public uint user_id;
            public byte user_status;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string user_name;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string dest_user;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
            public byte[] buffer;
        }

    public static class StructureMapper
    {
        public static byte[] ToByte(TPacket packet)
        {
            int size = 2 + packet.Length;
            byte[] retVal = new byte[size];
            unsafe
            {
                fixed (byte* ptr = retVal)
                {
                    *((TPacket*)ptr) = packet;
                } 
            }
 
            return retVal;
        }
 
        public static unsafe TPacket ToStruct(byte[] data)
        {
            fixed (byte* pointer = data)
                return *(TPacket*)pointer;
        }
 
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public unsafe struct TPacket
        {
            public byte Length;
            public byte OpCode;
            private fixed byte _data[254];
 
            public byte[] Data
            {
                get
                {
                    byte[] retVal = new byte[Length];
                    fixed (byte* ptr = retVal)
                    {
                        for (int i = 0; i < retVal.Length; i++)
                        {
                            retVal[i] = ptr[i];
                        }
                    }
                    return retVal;
                }
                set
                {
                    fixed (byte* ptr = _data)
                        for (int i = 0; i < value.Length; i++)
                        {
                            ptr[i] = value[i];
                        }
                }
            }
        }
    }

struct S
{
    public byte[] buffer;
}
 
//......где-то в теле метода
S.buffer = new byte[2];
byte[] bytes = StructToByte(S);
//......................................

private byte[] StructToByteArray(packege packet)
        {
            int sizeInBytes = System.Runtime.InteropServices.Marshal.SizeOf(packet);
            Console.WriteLine("Pck size: " + sizeInBytes);
            byte[] outArray = new byte[sizeInBytes];
            MemoryStream stream = new MemoryStream();
            StreamWriter writer = new StreamWriter(stream);
            writer.Write(packet.packet_version);
            writer.Write(packet.packet_type);
            writer.Write(packet.crs32_value);
            writer.Write(packet.result_code);
            writer.Flush();
            return stream.ToArray();
        }

public struct packege
        {
            public Int16 packet_version;
            public Int16 packet_type;
            public UInt32 crs32_value;
            public Int16 result_code;
        }

pack.packet_version = 28;
pack.packet_type = 2;
pack.crs32_value = 344912;
pack.result_code = 0;

pack.packet_version = (short)IPAddress.NetworkToHostOrder(reader.ReadInt16());