C#结构体和字节数组的转换

た入场券 2022-06-12 13:17 282阅读 0赞

[http://www.haogongju.net/art/624248][http_www.haogongju.net_art_624248]

在写C\#TCP[通信][Link 1]程序时，发送[数据][Link 2]时，只能发送byte数组，处理起来比较麻烦不说，如果是和[VC][]6.0等写的程序通信的话，很多的都是传送结构体，在VC6.0中[可以][Link 3]很方便的把一个char\[\]数组转换为一个结构体，而在C\#却不能直接把byte数组转换为结构体，要在C\#中发送结构体，可以按以下[方法][Link 4]实现：   
（1）[定义][Link 5]结构体：  
 //命名[空间][Link 6]  
 us[in][]g System.Runtime.Interop[Service][]s;

//[注意][Link 7]这个属性不能少  
 \[StructLayoutAttribute(LayoutKind.Sequential,CharSet=CharSet.Ansi,Pack=1)\]  
 struct TestStruct  
 \{   
 public int c;  
 //字符串，SizeConst为字符串的最大长度  
 \[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)\]  
 public string str;  
 //int数组，SizeConst表示数组的个数，在转换成  
 //byte数组前[必须][Link 8]先初始化数组，再使用，初始化  
 //的数组长度必须和SizeConst一致，例test = new int\[6\];  
 \[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)\]  
 public int\[\] test;  
 \}

（2）结构体转byte数组:  
 <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\];  
 //分配结构体大小的[内存][Link 9]空间  
 IntPtr structPtr = Marshal.AllocHGlobal(size);  
 //将结构体拷到分配好的内存空间  
 Marshal.StructureToPtr(structObj, structPtr, false);  
 //从内存空间拷到byte数组  
 Marshal.Copy(structPtr, bytes, 0, size);  
 //释放内存空间  
 Marshal.[Free][]HGlobal(structPtr);  
 //返回byte数组  
 return bytes;  
 \}  
（3）byte数组转结构体:  
 /// <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;  
 \}

尽管在C\#中结构与类有着惊人的相似度，但在实际[应用][Link 10]中，会常常因为[一些][Link 11]特殊之类而错误的使用它，下面几点[内容][Link 12]是笔者认为应该[注意][Link 7]的：

对于结构

1）[可以][Link 3]有[方法][Link 4]与属性  
2）是密封的，不能被继承，或继承其他结构  
3）结构隐式地继承自System.ValueType  
4）结构有默认的无参数[构造][Link 13]函数，可以将每个字段初始化为默认值，但这个默认的构造函数不能被替换，即使重载了带参数的构造函数  
5）结构没有析构函数  
6）除了const成员外，结构的字段不能在[声明][Link 14]结构时初始化  
7）结构是值类型，在[定义][Link 5]时（尽管也使用new运算符）会分配堆栈[空间][Link 6]，其值也[存储][Link 15]于堆栈  
8）结构主要用于小的[数据][Link 2]结构，为了更好的[性能][Link 16]，不要使用过于庞大的结构  
9）可以像类那样为结构[提供][Link 17] Close() 或 Dispose() 方法

如果经常做[通信][Link 1][方面][Link 18]的程序，结构体是非常有用的(为了更有效地组织数据，[建议][Link 19]使用结构体)，也会遇到字节数据与结构体相互转化的[问题][Link 20]，下面是一般[解决方法][Link 21]：

**[如何定义][Link 22]一个按字节顺序存储的结构体？**

1     [StructLayout(LayoutKind.Sequential, Pack = 1)]  //顺序排列，并按1字节对齐 （这里保存的是一组飞机参数,共73字节）
     2public struct StructPlane
     3     {

4public byte serialNum;
     5public double pitch;
     6public double roll;
     7public double yaw;
     8public double pitchVel;
     9public double rollVel;
    10public double yawVel;
    11public double alt;
    12public double vz;
    13public ushort pwm1;
    14public ushort pwm2;
    15public ushort pwm3;
    16public ushort pwm4;
    17     };

**结构体转字节数组的方法：**  
注：  
1. 一般PC用小端模式（即高位存放于高地址，低位存放于低地址，反之为大端模式）存放数据，如果另一通讯设备用大端存储数据，则相互转化时就要注意了。  
2. 结构体需按上面的方式，顺序排列并按1字节对齐，下面的所有方法都一样。

1 //需添加的引用，提供Marshal类
    2 using System.Runtime.InteropServices;
      3 
      4/// <summary>
      5/// 结构体转字节数组（按小端模式）
    6/// </summary>
      7/// <param name="obj">struct type</param>
      8/// <returns></returns>
      9byte[] StructureToByteArray(object obj)
     10         {
     11int len = Marshal.SizeOf(obj);
     12byte[] arr = new byte[len];
     13             IntPtr ptr = Marshal.AllocHGlobal(len);
     14             Marshal.StructureToPtr(obj, ptr, true);
     15             Marshal.Copy(ptr, arr, 0, len);
     16             Marshal.FreeHGlobal(ptr);
     17return arr;
     18         }
     19
     20         /// <summary>
     21/// 结构体转字节数组（按大端模式）
     22/// </summary>
     23/// <param name="obj">struct type</param>
     24/// <returns></returns>
     25byte[] StructureToByteArrayEndian(object obj)
     26         {
     27object thisBoxed = obj;   //copy ，将 struct 装箱
     28             Type test = thisBoxed.GetType();
     29 
     30int offset = 0;
     31byte[] data = new byte[Marshal.SizeOf(thisBoxed)];
     32 
     33object fieldValue;
     34             TypeCode typeCode;
     35byte[] temp;
     36// 列举结构体的每个成员，并Reverse
     37foreach (var field in test.GetFields())
     38             {
     39                 fieldValue = field.GetValue(thisBoxed); // Get value
     40 
     41                 typeCode = Type.GetTypeCode(fieldValue.GetType());  // get type
     42 
     43switch (typeCode)
     44                 {
     45case TypeCode.Single: // float
     46                         {
     47                             temp = BitConverter.GetBytes((Single)fieldValue);
     48                             Array.Reverse(temp);
     49                             Array.Copy(temp, 0, data, offset, sizeof(Single));
     50break;
     51                         }
     52case TypeCode.Int32:
     53                         {
     54                             temp = BitConverter.GetBytes((Int32)fieldValue);
     55                             Array.Reverse(temp);
     56                             Array.Copy(temp, 0, data, offset, sizeof(Int32));
     57break;
     58                         }
     59case TypeCode.UInt32:
     60                         {
     61                             temp = BitConverter.GetBytes((UInt32)fieldValue);
     62                             Array.Reverse(temp);
     63                             Array.Copy(temp, 0, data, offset, sizeof(UInt32));
     64break;
     65                         }
     66case TypeCode.Int16:
     67                         {
     68                             temp = BitConverter.GetBytes((Int16)fieldValue);
     69                             Array.Reverse(temp);
     70                             Array.Copy(temp, 0, data, offset, sizeof(Int16));
     71break;
     72                         }
     73case TypeCode.UInt16:
     74                         {
     75                             temp = BitConverter.GetBytes((UInt16)fieldValue);
     76                             Array.Reverse(temp);
     77                             Array.Copy(temp, 0, data, offset, sizeof(UInt16));
     78break;
     79                         }
     80case TypeCode.Int64:
     81                         {
     82                             temp = BitConverter.GetBytes((Int64)fieldValue);
     83                             Array.Reverse(temp);
     84                             Array.Copy(temp, 0, data, offset, sizeof(Int64));
     85break;
     86                         }
     87case TypeCode.UInt64:
     88                         {
     89                             temp = BitConverter.GetBytes((UInt64)fieldValue);
     90                             Array.Reverse(temp);
     91                             Array.Copy(temp, 0, data, offset, sizeof(UInt64));
     92break;
     93                         }
     94case TypeCode.Double:
     95                         {
     96                             temp = BitConverter.GetBytes((Double)fieldValue);
     97                             Array.Reverse(temp);
     98                             Array.Copy(temp, 0, data, offset, sizeof(Double));
     99break;
    100                         }
    101case TypeCode.Byte:
    102                         {
    103                             data[offset] = (Byte)fieldValue;
    104break;
    105                         }
    106default:
    107                         {
    108//System.Diagnostics.Debug.Fail("No conversion provided for this type : " + typeCode.ToString());
    109break;
    110                         }
    111                 }; // switch
    112if (typeCode == TypeCode.Object)
    113                 {
    114int length = ((byte[])fieldValue).Length;
    115                     Array.Copy(((byte[])fieldValue), 0, data, offset, length);
    116                     offset += length;
    117                 }
    118else
    119                 {
    120                     offset += Marshal.SizeOf(fieldValue);
    121                 }
    122             } // foreach
    123 
    124return data;
    125         } // Swap

**字节数组转结构体的方法：**

/// <summary>
    /// 字节数组转结构体(按小端模式)
    /// </summary>
    /// <param name="bytearray">字节数组</param>
    /// <param name="obj">目标结构体</param>
    /// <param name="startoffset">bytearray内的起始位置</param>
    public static void ByteArrayToStructure(byte[] bytearray, ref object obj, int startoffset)
            {
    int len = Marshal.SizeOf(obj);
                IntPtr i = Marshal.AllocHGlobal(len);
    // 从结构体指针构造结构体
    obj = Marshal.PtrToStructure(i, obj.GetType());
    try
                {
    // 将字节数组复制到结构体指针
    Marshal.Copy(bytearray, startoffset, i, len);
                }
    catch (Exception ex) { Console.WriteLine("ByteArrayToStructure FAIL: error " + ex.ToString()); }
                obj = Marshal.PtrToStructure(i, obj.GetType());
                Marshal.FreeHGlobal(i);  //释放内存，与 AllocHGlobal() 对应
    
    }
    
    /// <summary>
    /// 字节数组转结构体(按大端模式)
    /// </summary>
    /// <param name="bytearray">字节数组</param>
    /// <param name="obj">目标结构体</param>
    /// <param name="startoffset">bytearray内的起始位置</param>
    public static void ByteArrayToStructureEndian(byte[] bytearray, ref object obj, int startoffset)
            {
    int len = Marshal.SizeOf(obj);
                IntPtr i = Marshal.AllocHGlobal(len);
    byte[] temparray = (byte[])bytearray.Clone();
    // 从结构体指针构造结构体
    obj = Marshal.PtrToStructure(i, obj.GetType());
    // 做大端转换
    object thisBoxed = obj;
                Type test = thisBoxed.GetType();
    int reversestartoffset = startoffset;
    // 列举结构体的每个成员，并Reverse
    foreach (var field in test.GetFields())
                {
    object fieldValue = field.GetValue(thisBoxed); // Get value
    
                    TypeCode typeCode = Type.GetTypeCode(fieldValue.GetType());  //Get Type
    if (typeCode != TypeCode.Object)  //如果为值类型
    {
    Array.Reverse(temparray, reversestartoffset, Marshal.SizeOf(fieldValue));
                        reversestartoffset += Marshal.SizeOf(fieldValue);
                    }
    else//如果为引用类型
    {
    reversestartoffset += ((byte[])fieldValue).Length;
                    }
                }
    try
                {
    //将字节数组复制到结构体指针
    Marshal.Copy(temparray, startoffset, i, len);
                }
    catch (Exception ex) { Console.WriteLine("ByteArrayToStructure FAIL: error " + ex.ToString()); }
                obj = Marshal.PtrToStructure(i, obj.GetType());
                Marshal.FreeHGlobal(i);  //释放内存
    }

使用示例一：

... ...
    byte[] packet = new byte[73]{...};
    StructPlane structPlane = new StructPlane();             
    object structType = structPlane;
    ByteArrayToStructure(packet, ref structType, 0);

使用示例二：

StructPlane structPlane = new StructPlane();
    structPlane.serialNum = ...;
    structPlane.time = ...;
    structPlane.pitch = ...;
    ... ...
    byte[] datas = StructureToByteArray(structPlane);

[http://www.haogongju.net/art/1200066][http_www.haogongju.net_art_1200066]

[http_www.haogongju.net_art_624248]: http://www.haogongju.net/art/624248
[Link 1]: http://www.haogongju.net/tag/%E9%80%9A%E4%BF%A1
[Link 2]: http://www.haogongju.net/tag/%E6%95%B0%E6%8D%AE
[VC]: http://www.haogongju.net/tag/VC
[Link 3]: http://www.haogongju.net/tag/%E5%8F%AF%E4%BB%A5
[Link 4]: http://www.haogongju.net/tag/%E6%96%B9%E6%B3%95
[Link 5]: http://www.haogongju.net/tag/%E5%AE%9A%E4%B9%89
[Link 6]: http://www.haogongju.net/tag/%E7%A9%BA%E9%97%B4
[in]: http://www.haogongju.net/tag/in
[Service]: http://www.haogongju.net/tag/Service
[Link 7]: http://www.haogongju.net/tag/%E6%B3%A8%E6%84%8F
[Link 8]: http://www.haogongju.net/tag/%E5%BF%85%E9%A1%BB
[Link 9]: http://www.haogongju.net/tag/%E5%86%85%E5%AD%98
[Free]: http://www.haogongju.net/tag/Free
[Link 10]: http://www.haogongju.net/tag/%E5%BA%94%E7%94%A8
[Link 11]: http://www.haogongju.net/tag/%E4%B8%80%E4%BA%9B
[Link 12]: http://www.haogongju.net/tag/%E5%86%85%E5%AE%B9
[Link 13]: http://www.haogongju.net/tag/%E6%9E%84%E9%80%A0
[Link 14]: http://www.haogongju.net/tag/%E5%A3%B0%E6%98%8E
[Link 15]: http://www.haogongju.net/tag/%E5%AD%98%E5%82%A8
[Link 16]: http://www.haogongju.net/tag/%E6%80%A7%E8%83%BD
[Link 17]: http://www.haogongju.net/tag/%E6%8F%90%E4%BE%9B
[Link 18]: http://www.haogongju.net/tag/%E6%96%B9%E9%9D%A2
[Link 19]: http://www.haogongju.net/tag/%E5%BB%BA%E8%AE%AE
[Link 20]: http://www.haogongju.net/tag/%E9%97%AE%E9%A2%98
[Link 21]: http://www.haogongju.net/tag/%E8%A7%A3%E5%86%B3%E6%96%B9%E6%B3%95
[Link 22]: http://www.haogongju.net/tag/%E5%A6%82%E4%BD%95%E5%AE%9A%E4%B9%89
[http_www.haogongju.net_art_1200066]: http://www.haogongju.net/art/1200066