C# Socket系列三 socket通信的封包和拆包
2017-07-26 11:44
316 查看
通过系列二 我们已经实现了socket的简单通信 接下来我们测试一下，在时间应用的场景下，我们会快速且大量的传输数据的情况！
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 TCPListener tcp = new TCPListener();
6 TSocketClient client = new TSocketClient();
7 for (int i = 0; i < 10; i++)
8 {
9 client.SendMsg(System.Text.UTF8Encoding.Default.GetBytes("Holle Server！"));
10 }
11 Console.ReadLine();
12 }
13 }我们通过测试代码快速发送10条消息到服务器去，
我们看看运行结果
这样不难看出，我们的客户端发送了10条消息，但是服务器收到的时候变成了两条消息，回复客户端自然就变成两次回复。
这是为什么呢？
我们修改一下程序一秒钟发送一次消息试试
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 TCPListener tcp = new TCPListener();
6 TSocketClient client = new TSocketClient();
7 for (int i = 0; i < 5; i++)
8 {
9 Thread.Sleep(1000);
10 client.SendMsg(System.Text.UTF8Encoding.Default.GetBytes("Holle Server！"));
11 }
12 Console.ReadLine();
13 }
14 }运行看看，
这次对了那么分析分析到底为什么呢？ 这是socket的底层，做的手脚。因为我设置socket的发送和接受缓冲区 //10K的缓冲区空间 private int BufferSize = 10 * 1024; 10k的缓冲区， 且socket的底层 发送消息会有一定间隙，虽然这个时间很短，但是我们直接for循环发送的话，时间同意很快， 因为socket.send()方法并非真实的发送数据而是把数据压入发送缓冲区。 那么我们就明白了为什么会出现上面的情况 出现了这样的情况我们要怎么解决呢？ 时间应用场景不可能1秒钟才一条消息啥。 我们知道了导致这个问题的原因是因为消息发送是出现了快速压入很多发送消息到待发送缓冲区里面一起发送导致的。这样情况就是粘包了，那么我们是不是可以考虑给每一个消息加入包标识呢？
接下来我们修改一下发送包的数据代码
创建消息的构造体 TSocketMessage
1 /// <summary>
2 /// 底层通信消息
3 /// </summary>
4 public class TSocketMessage : IDisposable
5 {
6 /// <summary>
7 /// 消息ID
8 /// </summary>
9 public int MsgID;
10 /// <summary>
11 /// 消息内容
12 /// </summary>
13 public byte[] MsgBuffer;
14
15 public TSocketMessage(int msgID, byte[] msg)
16 {
17 this.MsgID = msgID;
18 this.MsgBuffer = msg;
19 }
20
21 public void Dispose()
22 {
23 this.Dispose(true);
24 GC.SuppressFinalize(this);
25 }
26
27 protected virtual void Dispose(bool flag1)
28 {
29 if (flag1) { this.MsgBuffer = null; }
30 }
31 }接下来我们创建消息包的封装和拆分 MarshalEndian
1 public class MarshalEndian
2 {
3 //用于存储剩余未解析的字节数
4 private List<byte> _LBuff = new List<byte>(2);
5 //默认是utf8的编码格式
6 private UTF8Encoding utf8 = new UTF8Encoding();
7
8 //包头1
9 const Int16 t1 = 0x55;
10 //包头2
11 const Int16 t2 = 0xAA;
12 //字节数常量 两个包头4个字节，一个消息id4个字节，封装消息长度 long 8个字节
13 const long ConstLenght = 12L;
14
15 public void Dispose()
16 {
17 this.Dispose(true);
18 GC.SuppressFinalize(this);
19 }
20
21 protected virtual void Dispose(bool flag1)
22 {
23 if (flag1)
24 {
25 IDisposable disposable2 = this.utf8 as IDisposable;
26 if (disposable2 != null) { disposable2.Dispose(); }
27 IDisposable disposable = this._LBuff as IDisposable;
28 if (disposable != null) { disposable.Dispose(); }
29 }
30 }
31
32 public byte[] Encode(TSocketMessage msg)
33 {
34 MemoryStream ms = new MemoryStream();
35 BinaryWriter bw = new BinaryWriter(ms, new UTF8Encoding());
36 byte[] msgBuffer = msg.MsgBuffer;
37
38 #region 封装包头
39 bw.Write((Int16)t1);
40 bw.Write((Int16)t2);
41 #endregion
42
43 #region 包协议
44 if (msgBuffer != null)
45 {
46 bw.Write((Int64)(msgBuffer.Length + 4));
47 bw.Write(msg.MsgID);
48 bw.Write(msgBuffer);
49 }
50 else { bw.Write((Int64)0); }
51 #endregion
52
53 bw.Close();
54 ms.Close();
55 bw.Dispose();
56 ms.Dispose();
57 return ms.ToArray();
58 }
59
60 public List<TSocketMessage> GetDcAppMess(byte[] buff, int len)
61 {
62 //拷贝本次的有效字节
63 byte[] _b = new byte[len];
64 Array.Copy(buff, 0, _b, 0, _b.Length);
65 buff = _b;
66 if (this._LBuff.Count > 0)
67 {
68 //拷贝之前遗留的字节
69 this._LBuff.AddRange(_b);
70 buff = this._LBuff.ToArray();
71 this._LBuff.Clear();
72 this._LBuff = new List<byte>(2);
73 }
74
75 List<TSocketMessage> list = new List<TSocketMessage>();
76 MemoryStream ms = new MemoryStream(buff);
77 BinaryReader buffers = new BinaryReader(ms, this.utf8);
78 try
79 {
80 byte[] _buff;
81 Label_0073:
82 //判断本次解析的字节是否满足常量字节数
83 if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
84 {
85 _buff = new byte[(int)(buffers.BaseStream.Length - buffers.BaseStream.Position)];
86 Array.Copy(buff, (int)buffers.BaseStream.Position, _buff, 0, _buff.Length);
87 this._LBuff.AddRange(_buff);
88 return list;
89 }
90 #region 包头读取
91 //循环读取包头
92 Label_00983:
93 Int16 tt1 = buffers.ReadInt16();
94 Int16 tt2 = buffers.ReadInt16();
95 if (!(tt1 == t1 && tt2 == t2))
96 {
97 long ttttt = buffers.BaseStream.Seek(-3, SeekOrigin.Current);
98 goto Label_00983;
99 }
100 #endregion
101
102 #region 包协议
103 long offset = buffers.ReadInt64();
104 #endregion
105
106 #region 包解析
107 //剩余字节数大于本次需要读取的字节数
108 if (offset < (buffers.BaseStream.Length - buffers.BaseStream.Position))
109 {
110 int msgID = buffers.ReadInt32();
111 _buff = new byte[offset - 4];
112 Array.Copy(buff, (int)buffers.BaseStream.Position, _buff, 0, _buff.Length);
113 list.Add(new TSocketMessage(msgID, _buff));
114 //设置偏移量 然后继续循环读取
115 buffers.BaseStream.Seek(offset, SeekOrigin.Current);
116 goto Label_0073;
117 }
118 else if (offset == (buffers.BaseStream.Length - buffers.BaseStream.Position))
119 {
120 int msgID = buffers.ReadInt32();
121 //剩余字节数刚好等于本次读取的字节数
122 _buff = new byte[offset - 4];
123 Array.Copy(buff, (int)buffers.BaseStream.Position, _buff, 0, _buff.Length);
124 list.Add(new TSocketMessage(msgID, _buff));
125 }
126 else
127 {
128 //剩余字节数刚好小于本次读取的字节数 存起来，等待接受剩余字节数一起解析
129 _buff = new byte[(int)(buffers.BaseStream.Length - buffers.BaseStream.Position + ConstLenght)];
130 Array.Copy(buff, (int)(buffers.BaseStream.Position - ConstLenght), _buff, 0, _buff.Length);
131 buff = _buff;
132 this._LBuff.AddRange(_buff);
133 }
134 #endregion
135
136 }
137 catch { }
138 finally
139 {
140 if (buffers != null) { buffers.Dispose(); }
141 buffers.Close();
142 if (buffers != null) { buffers.Dispose(); }
143 ms.Close();
144 if (ms != null) { ms.Dispose(); }
145 }
146 return list;
147 }
148 }接下来我们修改一下 TSocketBase 的 抽象方法
1 public abstract void Receive(TSocketMessage msg);
在修改接受消息回调函数
1 /// <summary>
2 /// 消息解析器
3 /// </summary>
4 MarshalEndian mersha = new MarshalEndian();
5
6 /// <summary>
7 /// 接收消息回调函数
8 /// </summary>
9 /// <param name="iar"></param>
10 private void ReceiveCallback(IAsyncResult iar)
11 {
12 if (!this.IsDispose)
13 {
14 try
15 {
16 //接受消息
17 ReceiveSize = _Socket.EndReceive(iar, out ReceiveError);
18 //检查状态码
19 if (!CheckSocketError(ReceiveError) && SocketError.Success == ReceiveError)
20 {
21 //判断接受的字节数
22 if (ReceiveSize > 0)
23 {
24 byte[] rbuff = new byte[ReceiveSize];
25 Array.Copy(this.Buffers, rbuff, ReceiveSize);
26 var msgs = mersha.GetDcAppMess(rbuff, ReceiveSize);
27 foreach (var msg in msgs)
28 {
29 this.Receive(msg);
30 }
31 //重置连续收到空字节数
32 ZeroCount = 0;
33 //继续开始异步接受消息
34 ReceiveAsync();
35 }
36 else
37 {
38 ZeroCount++;
39 if (ZeroCount == 5) { this.Close("错误链接"); }
40 }
41 }
42 }
43 catch (System.Net.Sockets.SocketException) { this.Close("链接已经被关闭"); }
44 catch (System.ObjectDisposedException) { this.Close("链接已经被关闭"); }
45 }
46 }这样我们完成了在收到消息后对数据包的解析。
修改一下TSocketClient的 Receive 重写方法
1 /// <summary>
2 /// 收到消息后
3 /// </summary>
4 /// <param name="rbuff"></param>
5 public override void Receive(TSocketMessage msg)
6 {
7 Console.WriteLine("Receive ID：" + msg.MsgID + " Msg：" + System.Text.UTF8Encoding.Default.GetString(msg.MsgBuffer));
8 if (isServer)
9 {
10 this.SendMsg(new TSocketMessage(msg.MsgID, System.Text.UTF8Encoding.Default.GetBytes("Holle Client！")));
11 }
12 }修改测试代码如下
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 TCPListener tcp = new TCPListener();
6 TSocketClient client = new TSocketClient();
7 for (int i = 1; i < 5; i++)
8 {
9 Thread.Sleep(1000);
10 client.SendMsg(new TSocketMessage(i, System.Text.UTF8Encoding.Default.GetBytes("Holle Server！")));
11 }
12 Console.ReadLine();
13 }
14 }运行结果
接受成功了，那么我们取消暂停状态，快速发送消息试试
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 TCPListener tcp = new TCPListener();
6 TSocketClient client = new TSocketClient();
7 for (int i = 1; i < 5; i++)
8 {
9 client.SendMsg(new TSocketMessage(i, System.Text.UTF8Encoding.Default.GetBytes("Holle Server！")));
10 }
11 Console.ReadLine();
12 }
13 }看看运行结果
瞬间完成了消息发送，也没有再出现第一次运行的那样~！
这样完美的解决了socket通信 在传输上发送粘包问题
下载程序完整代码
谢谢园友发现的问题，
问题是这样的原本的解包和封包的测试代码不够严谨导致解析包出现错误 感谢园友发现问题，并提出问题。
附上最新的代码
1 using System;
2 using System.Collections.Generic;
3 using System.IO;
4 using System.Linq;
5 using System.Text;
6 using System.Threading.Tasks;
7
8 namespace TSocket
9 {
10 public class MarshalEndian
11 {
12 //用于存储剩余未解析的字节数
13 private List<byte> _LBuff = new List<byte>(2);
14 //默认是utf8的编码格式
15 private UTF8Encoding utf8 = new UTF8Encoding();
16
17 //包头1
18 const Int16 t1 = 0x55;
19 //包头2
20 const Int16 t2 = 0xAA;
21 //字节数常量 两个包头4个字节，一个消息id4个字节，封装消息长度 int32 4个字节
22 const Int32 ConstLenght = 8;
23
24 public void Dispose()
25 {
26 this.Dispose(true);
27 GC.SuppressFinalize(this);
28 }
29
30 protected virtual void Dispose(bool flag1)
31 {
32 if (flag1)
33 {
34 IDisposable disposable2 = this.utf8 as IDisposable;
35 if (disposable2 != null) { disposable2.Dispose(); }
36 IDisposable disposable = this._LBuff as IDisposable;
37 if (disposable != null) { disposable.Dispose(); }
38 }
39 }
40
41 public byte[] Encode(TSocketMessage msg)
42 {
43 MemoryStream ms = new MemoryStream();
44 BinaryWriter bw = new BinaryWriter(ms, new UTF8Encoding());
45 byte[] msgBuffer = msg.MsgBuffer;
46
47 #region 封装包头
48 bw.Write((Int16)t1);
49 bw.Write((Int16)t2);
50 #endregion
51
52 #region 包协议
53 if (msgBuffer != null)
54 {
55 bw.Write((Int32)(msgBuffer.Length + 4));
56 bw.Write(msg.MsgID);
57 bw.Write(msgBuffer);
58 }
59 else { bw.Write((Int32)0); }
60 #endregion
61
62 bw.Close();
63 ms.Close();
64 bw.Dispose();
65 ms.Dispose();
66 return ms.ToArray();
67 }
68
69 public List<TSocketMessage> GetDcAppMess(byte[] buff, int len)
70 {
71 //拷贝本次的有效字节
72 byte[] _b = new byte[len];
73 Array.Copy(buff, 0, _b, 0, _b.Length);
74 buff = _b;
75 if (this._LBuff.Count > 0)
76 {
77 //拷贝之前遗留的字节
78 this._LBuff.AddRange(_b);
79 buff = this._LBuff.ToArray();
80 this._LBuff.Clear();
81 this._LBuff = new List<byte>(2);
82 }
83
84 List<TSocketMessage> list = new List<TSocketMessage>();
85 MemoryStream ms = new MemoryStream(buff);
86 BinaryReader buffers = new BinaryReader(ms, this.utf8);
87 try
88 {
89 byte[] _buff;
90 Label_00983:
91
92 #region 包头读取
93 //循环读取包头
94 //判断本次解析的字节是否满足常量字节数
95 if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
96 {
97 _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
98 this._LBuff.AddRange(_buff);
99 return list;
100 }
101 Int16 tt1 = buffers.ReadInt16();
102 Int16 tt2 = buffers.ReadInt16();
103 if (!(tt1 == t1 && tt2 == t2))
104 {
105 long ttttt = buffers.BaseStream.Seek(-3, SeekOrigin.Current);
106 goto Label_00983;
107 }
108 #endregion
109
110 #region 包协议
111 int offset = buffers.ReadInt32();
112 #endregion
113
114 #region 包解析
115 //剩余字节数大于本次需要读取的字节数
116 if (offset <= (buffers.BaseStream.Length - buffers.BaseStream.Position))
117 {
118 int msgID = buffers.ReadInt32();
119 _buff = buffers.ReadBytes(offset - 4);
120 list.Add(new TSocketMessage(msgID, _buff));
121 if ((buffers.BaseStream.Length - buffers.BaseStream.Position) > 0)
122 {
123 goto Label_00983;
124 }
125 }
126 else
127 {
128 //剩余字节数刚好小于本次读取的字节数 存起来，等待接受剩余字节数一起解析
129 _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position + ConstLenght));
130 this._LBuff.AddRange(_buff);
131 }
132 #endregion
133 }
134 catch (Exception ex) { Console.WriteLine(ex); }
135 finally
136 {
137 if (buffers != null) { buffers.Dispose(); }
138 buffers.Close();
139 if (buffers != null) { buffers.Dispose(); }
140 ms.Close();
141 if (ms != null) { ms.Dispose(); }
142 }
143 return list;
144 }
145 }
146 }http://www.cnblogs.com/ty408/p/4344868.html
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- C# Socket系列三 socket通信的封包和拆包
- C# Socket系列三 socket通信的封包和拆包
- C#实现Socket通信(同时监听多客户端)
- C#socket建立服务器并进行简单通信
- C#网络编程系列九：类似QQ的即时通信程序
- 转载: C#和C++结构体Socket通信
- Java系列讲座二：Socket网络通信实现聊天软件项目讲解（UDP）
- 基于TCP/UDP的Socket网络通信系列之网络基础篇（一）
- socket 通信 入门3 android 客户端 C# 服务端
- C#使用Socket实现服务器与多个客户端通信(简单的聊天系统)
- 详解C# Socket简单例子（服务器与客户端通信）
- 异步Socket通信编程的C#实现（2）
- C#中Socket通信编程的异步实现
- Flex与C#socket通信（二）
- C# Socket通信 小案例
- C#中Socket通信用法实例详解
- C#_socket拆包_封包_模拟乱序包
- DirectX编程：C#中利用Socket实现网络语音通信[初级版本]
- 用C#中的Socket连接实现服务器与客户端通信
- C# socket通信TCP和UDP方式