C# 将结构体转为字节流的方式

1、 将基础类型转为byte数组存储

  private byte[] CreateNetDataByteStream(ushort system, ushort host, ushort type, byte[] tx_buf, ushort msg_len, ushort flag)

         {

             if (tx_buf == null)

             {

                 return null;

             }

             try

             {

                 byte[] data = new byte[msg_len + NetDataHeadLen];

                 byte[] u16byte = new byte[];

                 u16byte = BitConverter.GetBytes(type);

                 Array.Copy(u16byte, , data, , );

                 u16byte = BitConverter.GetBytes(flag);

                 Array.Copy(u16byte, , data, , );

                 u16byte = BitConverter.GetBytes(msg_len);

                 Array.Copy(u16byte, , data, , );

                // u16byte = BitConverter.GetBytes(CommonConstant.MySystemID);

                 Array.Copy(u16byte, , data, , );

               //  u16byte = BitConverter.GetBytes((ushort)CommonConstant.MySeatName);

                 Array.Copy(u16byte, , data, , );

                 u16byte = BitConverter.GetBytes(system);

                 Array.Copy(u16byte, , data, , );

                 u16byte = BitConverter.GetBytes(host);

                 Array.Copy(u16byte, , data, , );

                 tx_buf.CopyTo(data, NetDataHeadLen);

                 return data;

             }

             catch

             {
                 return null;

             }

         }

2.C#中结构体 与 字节流 相互转化

方式一
        //将一个结构序列化为字节数组
               private IFormatter formatter = new BinaryFormatter();
        private ValueType deserializeByteArrayToInfoObj(byte[] bytes)
        {
            ValueType vt;
            if (bytes == null || bytes.Length == )
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream(bytes);
                stream.Position = ;
                stream.Seek(, SeekOrigin.Begin);
                vt = (ValueType)formatter.Deserialize(stream);
                stream.Close();
                return vt;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        //将一个结构序列化为字节数组
        private byte[] serializeInfoObjToByteArray(ValueType infoStruct)
        {
            if (infoStruct == null)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, infoStruct);

                byte[] bytes = new byte[(int)stream.Length];
                stream.Position = ;
                int count = stream.Read(bytes, , (int)stream.Length);
                stream.Close();
                return bytes;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

方式二
   /// <summary>
        /// 将字节数组转换为结构体
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object ByteaToStruct(byte[] bytes, Type type)
        {
            //得到结构体大小
            int size = Marshal.SizeOf(type);
            Math.Log(size, );

            if (size > bytes.Length)
                return null;
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将BYTE数组拷贝到分配好的内存空间
            Marshal.Copy(bytes, , structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内容空间
            Marshal.FreeHGlobal(structPtr);
            return obj;
        }
        /// <summary>
        /// 将结构转换为字节数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public byte[] StructTOBytes(object obj)
        {
            int size = Marshal.SizeOf(obj);
            //创建byte数组
            byte[] bytes = new byte[size];
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷贝到分配好的内存空间
            Marshal.StructureToPtr(obj, structPtr, false);
            //从内存空间拷贝到byte数组
            Marshal.Copy(structPtr, bytes,, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            return bytes;
        }

3. C# 结构体字节对齐

 [structLayout(Layoutkind.sequential,charset=charset.ansi)]
 Struct Mystruct
 {
 [MarshalAs(UnmanagedType.ByValArray,sizeConst=)]
 Public byte[] serial;
 Public byte Type;
 Public uint Sum;
 }

在上述结构体与字节流转换第二种方法中，获取结构体长度int size = Marshal.SizeOf(Mystruct);,并不是13，而是16。在内存特定类型数据结构起始地址通常有一定的对齐要求，比如32位机器的int起始地址必须是4的整数倍，结构通常也如此

需要添加[structLayout(Layoutkind.sequential,charset=charset.ansi,pack=1)]