Сериализация структур

        public static byte[] Serialize(object anything)
        {
            int size = Marshal.SizeOf(anything);
            byte[] data = new byte[size];
            GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
            Marshal.StructureToPtr(anything, handle.AddrOfPinnedObject(), false);
            handle.Free();
            return data;
        }
        public static T Deserialize<T>(byte[] data)
        {
            GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
            T temp = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
            handle.Free();
            return temp;
        }
 
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct Pack
        {
            public byte size;//размер пакета - 0
            public byte client;//кому - 1
            public byte sender;//от кого - 2
            public byte type;//тип сообщения
            public object data;//данные
        }
 
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct UserParam
        {
            public byte model;//размер пакета - 0
            public byte fx;//кому - 1
            public int color;
        }

        struct Header//здесь не будет ссылочных типов
        {
            public int Size;
        }
 
        private unsafe byte[] WriteData(object Data)
        {
            int HeadSize = Marshal.SizeOf(typeof(Header));
 
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream datastream = new MemoryStream();
 
            formatter.Serialize(datastream, Data);
            byte[] DataBytes = datastream.ToArray();
 
            Header head = new Header();
            head.Size = DataBytes.Length; 
 
            byte[] Result = new byte[HeadSize + head.Size];
 
            fixed (byte* Pointer = Result)
            {
                Marshal.StructureToPtr(head, new IntPtr(Pointer), false);
            }
 
            Buffer.BlockCopy(DataBytes, 0, Result, HeadSize, head.Size);
 
            return Result;
        }
 
        private unsafe Header ReadHeader(byte[] Data)
        {
            int HeadSize = Marshal.SizeOf(typeof(Header));
 
            byte[] HeadBytes = new byte[HeadSize];
            Buffer.BlockCopy(Data, 0, HeadBytes, 0, HeadBytes.Length);
 
            Header head;
            fixed (byte* Pointer = HeadBytes)
                head = (Header)Marshal.PtrToStructure(new IntPtr(Pointer), typeof(Header));
 
            return head;
        }
 
        private T ReadData<T>(byte[] data, Header head)
        {
            int DataSize = head.Size;
            int HeadSize = Marshal.SizeOf(typeof(Header));
 
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream datastream = new MemoryStream(data);
            datastream.Position = HeadSize;
 
            return (T)formatter.Deserialize(datastream);
        }