代码创新者

这个屌丝很懒，什么也没留下！

热门标签

深入浅出C#结构体——封装以太网心跳包的结构为例_c# 心跳包

作者：代码创新者 | 2024-01-29 15:47:06

踩

c# 心跳包

https://www.cnblogs.com/JerryMouseLi/p/12606920.html

1.应用背景
2.结构体解析
- 2.1.结构体存在栈中
- 2.2.结构体不需要手动释放
3.封装心跳包结构体
4.结构体静态帮助类
5.New出来的结构体是存在堆中还是栈中？
- 5.1.不带形参的结构体构造
- 5.2.带形参的结构体构造
6.性能测试
7.原因分析
8.下一篇:类与结构体性能对比测试——以封装网络心跳包为例
9.IL工具使用分享

1.应用背景

底端设备有大量网络报文（字节数组）：心跳报文，数据采集报文，告警报文上报。需要有对应的报文结构去解析这些字节流数据。

2.结构体解析

由此，我第一点就想到了用结构体去解析。原因有以下两点：

2.1.结构体存在栈中

类属于引用类型，存在堆中；结构体属于值类型，存在栈中，在一个对象的主要成员为数据且数据量不大的情况下，使用结构会带来更好的性能。

2.2.结构体不需要手动释放

属于托管资源，系统自动管理生命周期，局部方法调用完会自动释放，全局方法会一直存在。

3.封装心跳包结构体

心跳协议报文如下：

对应结构体封装如下：

    [StructLayout(LayoutKind.Sequential, Pack = 1)] // 按1字节对齐
    public struct TcpHeartPacket
    {
  [<span class="hljs-meta">MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)</span>]   <span class="hljs-comment">//结构体内定长数组</span>
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span>[] head;

  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span> type;

  [<span class="hljs-meta">MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)</span>]
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span>[] length;
 
  [<span class="hljs-meta">MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)</span>]
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span>[] Mac;
 
  [<span class="hljs-meta">MarshalAs(UnmanagedType.ByValArray, SizeConst = 104)</span>]
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span>[] data;<span class="hljs-comment">//数据体</span>
 
  [<span class="hljs-meta">MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)</span>]
  <span class="hljs-keyword">public</span> <span class="hljs-keyword">byte</span>[] tail;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4

4.结构体静态帮助类

主要实现了字节数组向结构体转换方法，以及结构体向字节数组的转换方法。

    public class StructHelper
    {
        //// <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;
        }
    <span class="hljs-comment"><span class="hljs-doctag">///</span> <span class="hljs-doctag">&lt;summary&gt;</span></span>
    <span class="hljs-comment"><span class="hljs-doctag">///</span> byte数组转结构体</span>
    <span class="hljs-comment"><span class="hljs-doctag">///</span> <span class="hljs-doctag">&lt;/summary&gt;</span></span>
    <span class="hljs-comment"><span class="hljs-doctag">///</span> <span class="hljs-doctag">&lt;param name="bytes"&gt;</span>byte数组<span class="hljs-doctag">&lt;/param&gt;</span></span>
    <span class="hljs-comment"><span class="hljs-doctag">///</span> <span class="hljs-doctag">&lt;param name="type"&gt;</span>结构体类型<span class="hljs-doctag">&lt;/param&gt;</span></span>
    <span class="hljs-comment"><span class="hljs-doctag">///</span> <span class="hljs-doctag">&lt;returns&gt;</span>转换后的结构体<span class="hljs-doctag">&lt;/returns&gt;</span></span>
    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">object</span> <span class="hljs-title">BytesToStuct</span>(<span class="hljs-params"><span class="hljs-keyword">byte</span>[] bytes, Type type</span>)
    </span>{
        <span class="hljs-comment">//得到结构体的大小</span>
        <span class="hljs-keyword">int</span> size = Marshal.SizeOf(type);
        <span class="hljs-comment">//byte数组长度小于结构体的大小</span>
        <span class="hljs-keyword">if</span> (size &gt; bytes.Length)
        {
            <span class="hljs-comment">//返回空</span>
            <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
        }
        <span class="hljs-comment">//分配结构体大小的内存空间</span>
        IntPtr structPtr = Marshal.AllocHGlobal(size);
        <span class="hljs-keyword">try</span>
        {
            <span class="hljs-comment">//将byte数组拷到分配好的内存空间</span>
            Marshal.Copy(bytes, <span class="hljs-number">0</span>, structPtr, size);
            <span class="hljs-comment">//将内存空间转换为目标结构体</span>
            <span class="hljs-keyword">return</span> Marshal.PtrToStructure(structPtr, type);
        }
        <span class="hljs-keyword">finally</span> 
        {
            <span class="hljs-comment">//释放内存空间</span>
            Marshal.FreeHGlobal(structPtr);
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

5.New出来的结构体是存在堆中还是栈中？

有同事说new出来的都会放在堆里，我半信半疑。怎么去确定，new出来的结构体到底放在哪里有两种方式，一种是使用Visual Studio的调试工具查看，这种方法找了好久没找到怎么去查看，路过的高手烦请指点下；第二种方法就是查看反编译dll的IL（Intermediate Language）语言。查看最终是以怎样的方式去实现的。不懂IL想了解IL的可以看此篇文章

5.1.不带形参的结构体构造

调用代码

  //初始化结构体
  TcpHeartPacket tcpHeartPacket = new TcpHeartPacket();
  //将上报的心跳报文ReceviveBuff利用结构体静态帮助类StructHelper的BytesToStuct方法将字节流转化成结构体
  tcpHeartPacket = (TcpHeartPacket)StructHelper.BytesToStuct(ReceviveBuff, tcpHeartPacket.GetType());
1
2
3
4
5

从对应的IL代码可以看出只是initobj，并没有newobj，其中newobj表示分配内存，完成对象初始化；而initobj表示对值类型的初始化。

newobj用于分配和初始化对象；而initobj用于初始化值类型。因此，可以说，newobj在堆中分配内存，并完成初始化；而initobj则是对栈上已经分配好的内存，进行初始化即可，因此值类型在编译期已经在栈上分配好了内存。
newobj在初始化过程中会调用构造函数；而initobj不会调用构造函数，而是直接对实例置空。
newobj有内存分配的过程；而initobj则只完成数据初始化操作。

initobj 的执行结果是，将tcpHeartPacket中的引用类型初时化为null，而基元类型则置为0。
综上，new 结构体（无参情况）是放在栈中的，只是做了null/0初始化。

5.2.带形参的结构体构造

接下来看下带形参的结构体存放位置。
简化版带形参的结构体如下：

    public struct TcpHeartPacket
    {
    <span class="hljs-keyword">public</span> TcpHeartPacket(byte _type)
    {
        <span class="hljs-class"><span class="hljs-keyword">type</span> </span>= _type;
     }
    <span class="hljs-keyword">public</span> byte <span class="hljs-class"><span class="hljs-keyword">type</span>;</span>

}
1
2
3
4
5
6
7
1
2
3

调用如下：

//带形参结构体new初始化
  TcpHeartPacket tcpHeartPacket = new TcpHeartPacket(0x1);
//类的new做对比
  IWorkThread __workThread = new WorkThread();
1
2
3
4
5

IL代码如下：

形成了鲜明的对比，new带参的结构体。IL只是去call（调用）ctor（结构体的构造函数），而下面的new类则直接就是newobj，实例化了一个对象存到堆空间去了。

综合5.1,5.2表明结构体的new确实是存在栈里的，而类的new是存在堆里的。

6.性能测试

测试结果如下：

使用结构体解析包需要几十个微妙，其实效率还是很差的。我用类封装成包，解析了，只需要几个微妙，性能差5到10倍。

7.原因分析

主要时间消耗在了BytesToStuct方法，代码详见4

心跳包里面用了很多byte[]字节数组，而字节数组本身需要在堆里开辟空间；
该方法进行了装箱拆箱操作；
分配内存在堆上，还是在堆上进行了copy操作；
拆装箱的IL代码如下：

装箱使用的box指令，取消装箱是 unbox.any 指令

8.下一篇:类与结构体性能对比测试——以封装网络心跳包为例

当数据比较大的时候，结构体这种数据复制机制会带来较大的开销。也难怪微软给出的准则中有一条：“当类型定义大于16字节时不要选用struct”。最终我也选择了类来封装以太网包的解析，性能可以达到微妙级，会在下一篇文章《类与结构体性能对比测试——以封装网络心跳包为例》中作详细描述。

9.IL工具使用分享

使用ildasm工具
VS2013外部工具中添加ildasm.exe
使用dnSpy工具
dnSpy的github地址

本文链接：https://www.cnblogs.com/JerryMouseLi/p/12606920.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/43382