C# Scoket处理粘包、分包

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
using System;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
 
namespace Player.Common.Sockets
{
    /// <summary>
    /// Socket连接,双向通信
    /// </summary>
    public class TcpSocketConnection
    {
        #region 构造函数
 
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="socket">维护的Socket对象</param>
        /// <param name="server">维护此连接的服务对象</param>
        /// <param name="recLength">接受缓冲区大小</param>
        public TcpSocketConnection(Socket socket, TcpSocketServer server, int recLength)
        {
            _socket = socket;
            _server = server;
            _recLength = recLength;
        }
 
        #endregion
 
        #region 私有成员
 
        private Socket _socket { get; }
        private bool _isRec { get; set; } = true;
        private TcpSocketServer _server { get; set; } = null;
        private bool _isClosed { get; set; } = false;
        private string _connectionId { get; set; } = Guid.NewGuid().ToString();
 
        private ManualResetEvent allDone { get; set; } = new ManualResetEvent(false);
        /// <summary>
        /// 接收区大小,单位:字节
        /// </summary>
        private int _recLength { get; set; }
        #endregion
 
        #region 外部接口
 
        int headSize = 4;//包头长度 固定4
        byte[] surplusBuffer = null;//不完整的数据包,即用户自定义缓冲区
        /// <summary>
        /// 开始接受客户端消息
        /// </summary>
        public void StartRecMsg()
        {
            try
            {
                while (true)
                {
                    allDone.Reset();
                    byte[] container = new byte[_recLength];
                    _socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
                    {
                        try
                        {
                            //bytes 为系统缓冲区数据
                            //bytesRead为系统缓冲区长度
                            int bytesRead = _socket.EndReceive(asyncResult);
                            if (bytesRead > 0)
                            {
                                if (surplusBuffer == null)//判断是不是第一次接收,为空说是第一次
                                {
                                    surplusBuffer = new byte[bytesRead];
                                    Array.Copy(container, 0, surplusBuffer, 0, bytesRead);
                                }
                                else
                                {
                                    byte[] container1 = new byte[bytesRead];
                                    Array.Copy(container, 0, container1, 0, bytesRead);
                                    surplusBuffer = surplusBuffer.Concat(container1).ToArray();//拼接上一次剩余的包,已经完成读取每个数据包长度
                                }
 
                                int haveRead = 0;
                                //这里totalLen的长度有可能大于缓冲区大小的(因为 这里的surplusBuffer 是系统缓冲区+不完整的数据包)
                                int totalLen = surplusBuffer.Length;
                                while (haveRead <= totalLen)
                                {
                                    //如果在N此拆解后剩余的数据包连一个包头的长度都不够
                                    //说明是上次读取N个完整数据包后,剩下的最后一个非完整的数据包
                                    if (totalLen - haveRead < headSize)
                                    {
                                        byte[] byteSub = new byte[totalLen - haveRead];
                                        //把剩下不够一个完整的数据包存起来
                                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                                        surplusBuffer = byteSub;
                                        totalLen = 0;
                                        break;
                                    }
                                    //如果够了一个完整包,则读取包头的数据
                                    byte[] headByte = new byte[headSize];
                                    Buffer.BlockCopy(surplusBuffer, haveRead, headByte, 0, headSize);//从缓冲区里读取包头的字节
                                    int bodySize = BitConverter.ToInt32(headByte, 0);//从包头里面分析出包体的长度
 
                                    //这里的 haveRead=等于N个数据包的长度 从0开始;0,1,2,3....N
                                    //如果自定义缓冲区拆解N个包后的长度 大于 总长度,说最后一段数据不够一个完整的包了,拆出来保存
                                    if (haveRead + headSize + bodySize > totalLen)
                                    {
                                        byte[] byteSub = new byte[totalLen - haveRead];
                                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                                        surplusBuffer = byteSub;
                                        break;
                                    }
                                    if (bodySize < 2)
                                    {
                                        WebLogHelper.Error(LogType.SysLog, $"bytesRead:{bytesRead},bodySize:{bodySize}");
                                        Close();
                                        break;
                                    }
                                    //处理正常消息
                                    byte[] recBytes = new byte[bodySize + headSize];
                                    Array.Copy(surplusBuffer, haveRead, recBytes, 0, bodySize + headSize);
                                    //取出消息内容
                                    HandleRecMsg?.Invoke(_server, this, recBytes);
                                    //依次累加当前的数据包的长度
                                    haveRead = haveRead + headSize + bodySize;
                                    if (headSize + bodySize == bytesRead)//如果当前接收的数据包长度正好等于缓冲区长度,则待拼接的不规则数据长度归0
                                    {
                                        surplusBuffer = null;//设置空 回到原始状态
                                        totalLen = 0;//清0
                                    }
                                }
                            }
                            //开始下一轮接收
                            if (_isRec && IsSocketConnected())
                            {
                                allDone.Set();
                                //StartRecMsg();
                            }
                        }
                        catch (ObjectDisposedException )
                        {
                        }
                        catch (Exception ex)
                        {
                            HandleException?.Invoke(ex);
                            Close();
                        }
                    }, null);
                    allDone.WaitOne();
                }
                 
            }
            catch (Exception ex)
            {
                HandleException?.Invoke(ex);
                Close();
            }
        }
 
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="bytes">数据字节</param>
        public void Send(byte[] bytes)
        {
            try
            {
                _socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, asyncResult =>
                {
                    try
                    {
                        int length = _socket.EndSend(asyncResult);
                        HandleSendMsg?.Invoke(_server, this, bytes);
                    }
                    catch (Exception ex)
                    {
                        HandleException?.Invoke(ex);
                    }
                }, null);
            }
            catch (Exception ex)
            {
                HandleException?.Invoke(ex);
            }
        }
 
        /// <summary>
        /// 发送字符串(默认使用UTF-8编码)
        /// </summary>
        /// <param name="msgStr">字符串</param>
        public void Send(string msgStr)
        {
            Send(Encoding.UTF8.GetBytes(msgStr));
        }
 
        /// <summary>
        /// 发送字符串(使用自定义编码)
        /// </summary>
        /// <param name="msgStr">字符串消息</param>
        /// <param name="encoding">使用的编码</param>
        public void Send(string msgStr, Encoding encoding)
        {
            Send(encoding.GetBytes(msgStr));
        }
 
        /// <summary>
        /// 连接标识Id
        /// 注:用于标识与客户端的连接
        /// </summary>
        public string ConnectionId
        {
            get
            {
                return _connectionId;
            }
            set
            {
                string oldConnectionId = _connectionId;
                _connectionId = value;
                _server?.SetConnectionId(this, oldConnectionId, value);
            }
        }
 
        /// <summary>
        /// 关闭当前连接
        /// </summary>
        public void Close()
        {
 
            WebLogHelper.Error(LogType.SysLog, "自动关闭");
            if (_isClosed)
                return;
            try
            {
                _isClosed = true;
                _server.RemoveConnection(this);
 
                _isRec = false;
                _socket.BeginDisconnect(false, (asyncCallback) =>
                {
                    try
                    {
                        _socket.EndDisconnect(asyncCallback);
                    }
                    catch (Exception ex)
                    {
                        HandleException?.Invoke(ex);
                    }
                    finally
                    {
                        _socket.Dispose();
                    }
                }, null);
            }
            catch (Exception ex)
            {
                WebLogHelper.Info(LogType.SysLog, "断开连接报错");
                HandleException?.Invoke(ex);
            }
            finally
            {
                try
                {
                    HandleClientClose?.Invoke(_server, this);
                }
                catch (Exception ex)
                {
                    WebLogHelper.Info(LogType.SysLog, "调用关闭事件报错");
                    HandleException?.Invoke(ex);
                }
            }
        }
 
        /// <summary>
        /// 判断是否处于已连接状态
        /// </summary>
        /// <returns></returns>
        public bool IsSocketConnected()
        {
            return !((_socket.Poll(1000, SelectMode.SelectRead) && (_socket.Available == 0)) || !_socket.Connected);
        }
 
        #endregion
 
        #region 事件处理
 
        /// <summary>
        /// 客户端连接接受新的消息后调用
        /// </summary>
        public Action<TcpSocketServer, TcpSocketConnection, byte[]> HandleRecMsg { get; set; }
 
        /// <summary>
        /// 客户端连接发送消息后回调
        /// </summary>
        public Action<TcpSocketServer, TcpSocketConnection, byte[]> HandleSendMsg { get; set; }
 
        /// <summary>
        /// 客户端连接关闭后回调
        /// </summary>
        public Action<TcpSocketServer, TcpSocketConnection> HandleClientClose { get; set; }
 
        /// <summary>
        /// 异常处理程序
        /// </summary>
        public Action<Exception> HandleException { get; set; }
 
        #endregion
    }
}

 

posted @   听海漫步  阅读(2152)  评论(1编辑  收藏  举报
点击右上角即可分享
微信分享提示