请问如何将C#中的结构体转换为byte[]

Question

用UDPClient进行以太网通信，要向网络中广播发送一个结构体数据包
但是send函数仅能发送byte[]，不知道如何将我声明的结构体对象转换为byte[]进行发送，谢谢

Answer 1

 /// <summary>
        /// 结构提转换BYTE 
        /// </summary>
        /// <param name="p_StructObj">结构体</param>
        /// <returns></returns>
        public static byte[] StructToBytes(object p_StructObj)
        {           
            int _StuctSize = Marshal.SizeOf(p_StructObj);           
            byte[] _StuctBytes = new byte[_StuctSize];           
            IntPtr _StructIntPtr = Marshal.AllocHGlobal(_StuctSize);         
            Marshal.StructureToPtr(p_StructObj, _StructIntPtr, false);         
            Marshal.Copy(_StructIntPtr, _StuctBytes, 0, _StuctSize);         
            Marshal.FreeHGlobal(_StructIntPtr);         
            return _StuctBytes;
        }

Answer 2

我以前都是手动转，楼上的方法没有试过，
好像还可以用API的一个方法转

Answer 3

提供一个类给lz参考using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Management;namespace Util
{
    public class NetStreamUtil
    {
        private static byte _fillChar = 0; //the fill character
        
        //convert string to byte array in Ascii with length is len        
        public static byte[] StringToBytes(string str, int len)
        {
            if (string.IsNullOrEmpty(str))
            {
                str = string.Empty;
            }
 
            byte[] result = new byte[len];
            byte[] strBytes = Encoding.Default.GetBytes(str);            //copy the array converted into result, and fill the remaining bytes with 0
            for (int i = 0; i < len; i++)
                result[i] = ((i < strBytes.Length) ? strBytes[i] : _fillChar);
            
            return result;
        }        /// <summary>
        /// struct转换为byte[]
        /// </summary>
        /// <param name="structObj">结构体对象</param>
        /// <returns>字节数组</returns>
        public static byte[] StructToBytes(object structObj)
        {
            int size = Marshal.SizeOf(structObj);
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try
            {
                Marshal.StructureToPtr(structObj, buffer, false);
                byte[] bytes = new byte[size];
                Marshal.Copy(buffer, bytes, 0, size);
                return bytes;
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }       /// <summary>
       ///  byte[]转换为struct
       /// </summary>
       /// <param name="bytes"></param>
       /// <param name="strcutType"></param>
       /// <returns></returns>
       public static object BytesToStruct(byte[] bytes, Type strcutType)   
       {   
             int size = Marshal.SizeOf(strcutType);   
             IntPtr buffer = Marshal.AllocHGlobal(size);   
             try   
             {   
                Marshal.Copy(bytes, 0, buffer, size);   
                return Marshal.PtrToStructure(buffer, strcutType);   
             }   
             finally   
             {   
                Marshal.FreeHGlobal(buffer);   
             }   
        }         /// <summary>
        /// IntPtr转换成byte[]
        /// </summary>
        /// <param name="dataBuf"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public byte[] ConvertToBytes(IntPtr dataBuf, int length)
        {
            byte[] byteBuf = new byte[length];
            Marshal.Copy(dataBuf, byteBuf, 0, length);
            return byteBuf;
        }        /// <summary>
        /// 获得网卡号
        /// </summary>
        /// <returns></returns>
        public static string GetNetCardMacAddress()
        {
            ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
            ManagementObjectCollection moc = mc.GetInstances();
            string str = "";
            foreach (ManagementObject mo in moc)
            {
                if ((bool)mo["IPEnabled"] == true)
                    str = mo["MacAddress"].ToString();
            }
            return str;
        }
    }
}

Answer 4

或者使用unsafe代码：
        static void Main()
        {
            MyStruct s = new MyStruct();
            s.Low = 5;
            s.Hi = 10;
            Console.WriteLine(s.Value);
            byte[] b = new byte[4];
            unsafe
            {
                MyStruct* sptr = &s;
                fixed (byte* bptr = b)
                    for (int i = 0; i < sizeof(MyStruct); i++)
                        *(bptr + i) = *(((byte*)sptr) + i);
            }
            Console.WriteLine(BitConverter.ToString(b));
            Console.ReadLine();
        }        [StructLayout(LayoutKind.Explicit)]
        public struct MyStruct
        {
            [FieldOffset(0)]
            public int Value;
            [FieldOffset(0)]
            public short Low;
            [FieldOffset(2)]
            public short Hi;
        }

Answer 5

二进制流序列化就行了.
这样反过来由byte还原为结构的代码也简单.

Answer 6

二进制流序列化就行了.
这样反过来由byte还原为结构的代码也简单.

Answer 7

二进制流序列化就行了.
这样反过来由byte还原为结构的代码也简单.