【转】Socket接收字节缓冲区

原创本拉灯

2014年04月16日 10:06:55

• 标签：
• socket /
• 数据包

• 4448

我们接收Socket字节流数据一般都会定义一个数据包协议( 协议号,长度,内容),由于Socket接收数据是连续的，对方发两个包过来，Socket的 Recive事件有可能只触发一次或触发三次，也就是大家听到的粘包，为解决这个粘包，所以我们必要建一个字节缓冲区，将所有的接收到的字节流全放到这个缓冲区内 由这个缓冲区来分隔每个数据包的内容。

这份代码也是为论坛某个人解决串口接收数据包时而写的。不多说了上代码：

1. /// <summary>
2. /// 字节缓冲器
3. /// </summary>
4. public class ByteQueue
5. {
6. private List<byte> m_buffer = new List<byte>();
7. public bool Find()
8. {
9. if (m_buffer.Count == 0)
10. return false;
11. int HeadIndex = m_buffer.FindIndex(o => o == 0xAA);
12. if (HeadIndex == -1)
13. {
14. m_buffer.Clear();
15. return false; //没找到AA
16. }
17. else if (HeadIndex != 0) //不为开头移掉之前的字节
18. {
19. if (HeadIndex > 1)
20. m_buffer.RemoveRange(0, HeadIndex);
21. }
22. int length= GetLength();
23. if (m_buffer.Count <length)
24. {
25. return false;
26. }
27. int TailIndex = m_buffer.FindIndex(o => o == 0x55); //查找55的位置
28. if (TailIndex == -1)
29. {
30. //这一步为防止连发一个AA开头的包后，没发55，而又发了一个AA
31. int head = m_buffer.FindLastIndex(o => o == 0xAA);
32. if (head > -1)
33. {
34. m_buffer.RemoveRange(0, head);
35. }
36. return false;
37. }
38. else if (TailIndex + 1 != length) //计算包尾是否与包长度相等
39. {
40. m_buffer.RemoveRange(0, TailIndex);
41. return false;
42. }
43. return true;
44. }
45. /// <summary>
46. /// 命令类型
47. /// </summary>
48. /// <returns></returns>
49. public byte Cmd()
50. {
51. if (m_buffer.Count >= 2)
52. {
53. return m_buffer[1];
54. }
55. return 0;
56. }
57. /// <summary>
58. /// 序号
59. /// </summary>
60. /// <returns></returns>
61. public byte Number()
62. {
63. if (m_buffer.Count >= 3)
64. {
65. return m_buffer[2];
66. }
67. return 0;
68. }
69. /// <summary>
70. /// 包长度
71. /// </summary>
72. /// <returns></returns>
73. public int GetLength()
74. {
75. int len = 5;//AA 命令类型 序号 校验和 55
76. if (m_buffer.Count >= 3)
77. {
78. switch (m_buffer[2]) //第三字节为序号
79. {
80. case 0x00: //序号
81. return len + 16;
82. case 0x01: //序号
83. return len + 10;
84. case 0x02: //序号
85. return len + 12;
86. }
87. }
88. return 0;
89. }
90. /// <summary>
91. /// 提取数据
92. /// </summary>
93. public void Dequeue(byte[] buffer, int offset,int size)
94. {
95. m_buffer.CopyTo(0,buffer,offset,size);
96. m_buffer.RemoveRange(0, size);
97. }
98. /// <summary>
99. /// 队列数据
100. /// </summary>
101. /// <param name="buffer"></param>
102. public void Enqueue(byte[] buffer)
103. {
104. m_buffer.AddRange(buffer);
105. }
106. }

调用列子：

1. private ByteQueue queue = new ByteQueue();
2. private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
3. {
4. int len = serialPort1.BytesToRead;
5. if (len > 0)
6. {
7. byte[] temp = new byte[len];
8. serialPort1.Read(temp, 0, len);
9. queue.Enqueue(temp);
10. while (queue.Find()) //while可处理同时接收到多个AA ... 55 ,AA...55的包
11. {
12. int length = queue.GetLength();
13. byte[] readBuffer = new byte[len];
14. queue.Dequeue(readBuffer, 0, length);
15. OnReceiveData(readBuffer); //<这里自己写一个委托吧就OK了
16. }
17. }
18. }

上面的字节接收容器是用List来处理为方便进出字节后移除整个数据包的字节数据，当然更高效的应用byte[] 数组作成环形缓冲会好很多相对应的写法也会难一些，