C# 结构体定义 转换字节数组 z

客户端采用C++开发，服务端采用C#开发，所以双方必须保证各自定义结构体成员类型和长度一致才能保证报文解析的正确性.

[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = )]
    public struct Head
    {
        public ushort proMagic;          //包起始标记：固定0x7e7e
        public ushort proPackLen;        //包长度：包头 + 数据区 + 包尾长度，注意不要超过最大长度限制
        public long   proSrcAddr;        //源地址：不使用，填0
        public ushort proSrcPort;        //源地址端口:不使用，填0
        public long   proDstAddr;        //目的地址：不使用，填0
        public ushort proDstPort;        //目的端口：不使用，填0
        public ushort proCmdCode;        //命令码：参见以上命令码定义

        public ushort proVersion;        //版本号：不使用，填1
        public char   proSerial;         //报文序号：一条报文实例对应一个序号，不同报文叠加，0-255往复
        public ushort proPackSum;        //总包数：当包长超过最大长度限制时，需要拆包，大包拆小包总数，不拆默认1
        public ushort proPackId;         //当前包号：对应以上总包数的小包标识，不拆默认0

    }

一、首先是 [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]，这是C#引用非托管的C/C++的DLL的一种定义定义结构体的方式，主要是为了内存中排序，LayoutKind有两个属性Sequential和Explicit，Sequential表示顺序存储，结构体内数据在内存中都是顺序存放的，CharSet=CharSet.Ansi表示编码方式。这都是为了使用非托管的指针准备的，这两点大家记住就可以。

       需要注意的是 Pack = 1 这个特性，它代表了结构体的字节对齐方式，在实际开发中，C++开发环境开始默认是2字节对齐方式 ，拿上面报文包头结构体为例，char类型在虽然在内存中至占用一个字节，但在结构体转为字节数组时，系统会自动补齐两个字节，所以如果C#这面定义为Pack=1,C++默认为2字节对齐的话，双方结构体会出现长度不一致的情况，相互转换时必然会发生错位，所以需要大家都默认1字节对齐的方式，C#定义Pack=1,C++ 添加 #pragma pack 1，保证结构体中字节对齐方式一致。

二、数组的定义，结构体中每个成员的长度都是需要明确的，因为内存需要根据这个分配空间，而C#结构体中数组是无法进行初始化的，这里我们需要在成员声明时进行定义；

    /// <summary>
    /// 终端信息查询
    /// </summary>
    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct PackTerminalSearch5001
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 6)]
        /// <summary>
        /// 终端编号
        /// </summary>
        public string stationCode;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
        /// <summary>
        /// 回复指令
        /// </summary>
        public Byte[] order;
    }
    /// <summary>
    /// 终端信息数据
    /// </summary>

    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct PackTerminalSearch3004
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 6)]
        /// <summary>
        /// 终端编号
        /// </summary>
        public string stationCode;
        /// <summary>
        /// 终端IP
        /// </summary>
        public long terminalIP;
        /// <summary>
        /// 终端端口
        /// </summary>
        public ushort terminalPort;
        /// <summary>
        /// 中心IP
        /// </summary>
        public long serverIP;
        /// <summary>
        /// 测站端口
        /// </summary>
        public ushort serverPort;
        /// <summary>
        /// 磁盘信息数组
        /// </summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public PackDiskInfo[] diskInfoArray;
    }

    /// <summary>
    /// 磁盘信息
    /// </summary>
    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct PackDiskInfo
    {
        /// <summary>
        /// 盘符
        /// </summary>
        public char drive;
        /// <summary>
        /// 总空间
        /// </summary>
        public double totalSize;
        /// <summary>
        /// 可用空间
        /// </summary>
        public double usableSize;
    }

上面的代码需要注意的是string类型实际为Char[6]长度的数组，实际使用中只能有效的使用前5个字符，因为char[6]最后一位默认\0；

三、结构体与字节数组的互转

        PackTerminalSearch5001 info;
        info.stationCode = "12345";
        info.order = new byte[6] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
        Byte[] recv = StructToBytes(info);

        object obj = BytesToStuct(recv, typeof(PackTerminalSearch5001));
        PackTerminalSearch5001 info5001 = (PackTerminalSearch5001)obj;
        byte[] order =  info5001.order;

        //// <summary>
        /// 结构体转byte数组
        /// </summary>
        /// <param name="structObj">要转换的结构体</param>
        /// <returns>转换后的byte数组</returns>
        public static byte[] StructToBytes(object structObj)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(structObj);
            //创建byte数组
            byte[] bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷到分配好的内存空间
            Marshal.StructureToPtr(structObj, structPtr, false);
            //从内存空间拷到byte数组
            Marshal.Copy(structPtr, bytes, 0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回byte数组
            return bytes;
        }

        /// <summary>
        /// byte数组转结构体
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <param name="type">结构体类型</param>
        /// <returns>转换后的结构体</returns>
        public static object BytesToStuct(byte[] bytes, Type type)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(type);
            //byte数组长度小于结构体的大小
            if (size > bytes.Length)
            {
                //返回空
                return null;
            }
            //分配结构体大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将byte数组拷到分配好的内存空间
            Marshal.Copy(bytes, 0, structPtr, size);
            //将内存空间转换为目标结构体
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回结构体
            return obj;
        }