结构体转byte数组

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

        /// <summary>
        /// 两个结构体转换byte数组
        /// </summary>
        /// <param name="structObj">结构体对象</param>
        /// <returns></returns>
        public static byte[] StructToBytes(object structObj1, object structObj2)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(structObj1) + Marshal.SizeOf(structObj2);
            //创建char数组
            byte[] _bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr1 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj1));
            IntPtr structPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj2));

            //将结构体拷到分配好的内存空间

            Marshal.StructureToPtr(structObj1, structPtr1, false);
            Marshal.StructureToPtr(structObj2, structPtr2, false);

            //从内存空间拷到char数组
            Marshal.Copy(structPtr1, _bytes, 0, Marshal.SizeOf(structObj1));
            Marshal.Copy(structPtr2, _bytes, Marshal.SizeOf(structObj1), Marshal.SizeOf(structObj2));
            //释放内存空间
            Marshal.FreeHGlobal(structPtr1);
            Marshal.FreeHGlobal(structPtr2);
            //返回byte数组
            return _bytes;
        }

        /// <summary>
        /// 结构体数组转byte数组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listObj"></param>
        /// <returns></returns>
        public static byte[] StructToBytes<T>(List<T> listObj) where T: struct 
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(typeof(T));

            int nCount = listObj.Count;
            //创建char数组
            byte[] bytes = new byte[nCount * size];

            for (int i = 0; i < nCount; i++)
            {
                T structObj = listObj[i];
                //分配结构体大小的内存空间
                IntPtr pData = Marshal.AllocHGlobal(size);
                //将结构体拷到分配好的内存空间
                Marshal.StructureToPtr(structObj, pData, false);
                //从内存空间拷到char数组
                Marshal.Copy(pData, bytes, i * size, size);
                //释放内存空间
                Marshal.FreeHGlobal(pData);
            }
            //返回byte数组
            return bytes;
        }
        
        /// <summary>
        /// 多个结构体转换为数组
        /// </summary>
        /// <param name="listStruct"></param>
        /// <returns></returns>
        public static byte[] StructToBytes(List<object> listStruct)
        {
            //得到结构体的大小
            var allSize = 0;
            List<int[]> listPosition = new List<int[]>();
            foreach (var objStruct in listStruct)
            {
                var size = Marshal.SizeOf(objStruct);
                listPosition.Add(new[] { size, allSize });
                allSize += size;
            }

            //创建char数组
            byte[] bytes = new byte[allSize];

            foreach (var objStruct in listStruct)
            {
                int index = listStruct.IndexOf(objStruct); //index 为索引值 

                //获取结构体大小
                var nSize = listPosition[index][0];
                var nStartPosition = listPosition[index][1];
                //分配结构体大小的内存空间
                IntPtr structPtr = Marshal.AllocHGlobal(nSize);
                //将结构体拷到分配好的内存空间
                Marshal.StructureToPtr(objStruct, structPtr, false);
                //从内存空间拷到char数组
                Marshal.Copy(structPtr, bytes, nStartPosition, nSize);
                //释放内存空间
                Marshal.FreeHGlobal(structPtr);
            }
            //返回byte数组
            return bytes;
        }

        public static byte[] StructToBytes2(object structObj1, object structObj2)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(structObj1) + Marshal.SizeOf(structObj2);
            //创建char数组
            byte[] bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr1 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj1));
            IntPtr structPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj2));

            //将结构体拷到分配好的内存空间

            Marshal.StructureToPtr(structObj1, structPtr1, false);
            Marshal.StructureToPtr(structObj2, structPtr2, false);

            //从内存空间拷到char数组
            Marshal.Copy(structPtr1, bytes, 0, Marshal.SizeOf(structObj1));
            Marshal.Copy(structPtr2, bytes, Marshal.SizeOf(structObj1), Marshal.SizeOf(structObj2));
            //释放内存空间
            Marshal.FreeHGlobal(structPtr1);
            Marshal.FreeHGlobal(structPtr2);
            //返回byte数组
            return bytes;
        }
        
        public static byte[] StructToBytes3(object structObj1, object structObj2, IntPtr structObj3, int nSize)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(structObj1) + Marshal.SizeOf(structObj2) + nSize;
            //创建char数组
            byte[] bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr1 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj1));
            IntPtr structPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(structObj2));

            //将结构体拷到分配好的内存空间

            Marshal.StructureToPtr(structObj1, structPtr1, false);
            Marshal.StructureToPtr(structObj2, structPtr2, false);

            //从内存空间拷到char数组
            Marshal.Copy(structPtr1, bytes, 0, Marshal.SizeOf(structObj1));
            Marshal.Copy(structPtr2, bytes, Marshal.SizeOf(structObj1), Marshal.SizeOf(structObj2));
            Marshal.Copy(structObj3, bytes, Marshal.SizeOf(structObj1) + Marshal.SizeOf(structObj2), nSize);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr1);
            Marshal.FreeHGlobal(structPtr2);

            //返回byte数组
            return bytes;
        }

        public static List<T> Byte2Struct<T>(byte[] arr)
        {
            List<T> listT = new List<T>();
            int nByteSize = arr.Length;
            IntPtr pData = Marshal.AllocHGlobal(nByteSize);
            Marshal.Copy(arr, 0, pData, nByteSize);

            int nStructSize = Marshal.SizeOf(typeof(T));

            while (nByteSize >= nStructSize)
            {
                T struObj = (T)Marshal.PtrToStructure(pData, typeof(T));
                PtrMoveSize(ref pData, nStructSize);
                nByteSize -= nStructSize;
                listT.Add(struObj);
            }
            //Marshal.FreeHGlobal(pData);
            return listT;
        }
       
        //指针偏移
        public static void PtrMoveSize(ref IntPtr pData, int nLength)
        {
            pData = IntPtr.Size == sizeof(Int64) ? new IntPtr(pData.ToInt64() + nLength) : new IntPtr(pData.ToInt32() + nLength);
        }

        #endregion
        
        #region 结构体转指针
      
        public static IntPtr StructToIntPtr(Object obj1)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(obj1);
            //分配结构体大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(obj1, structPtr, false);
            return structPtr;
        }
        #endregion