使用完成端口（IOCP）

 1 using System;
 2 using System.Net;
 3 using System.Net.Sockets;
 4 
 5 namespace JCommon.Net
 6 {
 7     /// <summary>
 8     /// 存储客户端信息， 这个可以根据自己的实际情况来定义
 9     /// </summary>
10     public class AsyncUserToken
11     {
12         public IPEndPoint EndPort;
13         
14         public Socket Socket;
15         
16         /// <summary>
17         /// 连接时间
18         /// </summary>
19         public DateTime ConnectTime { get; set; }
20     }
21 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Net.Sockets;
 4 
 5 namespace JCommon.Net
 6 {
 7     /// <summary>
 8     /// 该类创建一个大缓冲区，该缓冲区可以分配给 SocketAsyncEventArgs 对象；
 9     /// 这使bufffer易于重用，并能防止碎片化堆内存；
10     /// BufferManager 类的操作不是线程安全的。
11     /// </summary>
12     internal class BufferManager
13     {
14         private int m_numBytes;             // 字节总数
15         private byte[] m_buffer;            // 字节数组
16         private Stack<int> m_freeIndexPool;
17         private int m_currentIndex;
18         private int m_bufferSize;
19 
20         public BufferManager(int totalBytes, int bufferSize)
21         {
22             this.m_numBytes = totalBytes;
23             this.m_currentIndex = 0;
24             this.m_bufferSize = bufferSize;
25             this.m_freeIndexPool = new Stack<int>();
26         }
27 
28         public void InitBuffer()
29         {
30             this.m_buffer = new byte[this.m_numBytes];
31         }
32 
33         /// <summary>
34         /// 将缓冲区分配给 SocketAsyncEventArgs 对象
35         /// </summary>
36         /// <param name="args"></param>
37         /// <returns></returns>
38         public bool SetBuffer(SocketAsyncEventArgs args)
39         {
40             if (this.m_freeIndexPool.Count > 0)
41             {
42                 args.SetBuffer(this.m_buffer, this.m_freeIndexPool.Pop(), this.m_bufferSize);
43             }
44             else
45             {
46                 if (this.m_numBytes - this.m_bufferSize < this.m_currentIndex)
47                 {
48                     return false;
49                 }
50                 args.SetBuffer(this.m_buffer, this.m_currentIndex, this.m_bufferSize);
51                 this.m_currentIndex += this.m_bufferSize;
52             }
53             return true;
54         }
55 
56         /// <summary>
57         /// 从 SocketAsyncEventArgs 对象回收缓冲区
58         /// </summary>
59         /// <param name="args"></param>
60         public void FreeBuffer(SocketAsyncEventArgs args)
61         {
62             this.m_freeIndexPool.Push(args.Offset);
63             args.SetBuffer(null, 0, 0);
64         }
65     }
66 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Net.Sockets;
 4 
 5 namespace JCommon.Net
 6 {
 7     /// <summary>
 8     /// 表示可重用SocketAsyncEventArgs对象的集合
 9     /// </summary>
10     internal class SocketAsyncEventArgsPool
11     {
12         private Stack<SocketAsyncEventArgs> m_pool;
13         
14         public SocketAsyncEventArgsPool(int capacity)
15         {
16             this.m_pool = new Stack<SocketAsyncEventArgs>(capacity);
17         }
18 
19         public void Push(SocketAsyncEventArgs item)
20         {
21             if (item == null)
22             {
23                 throw new ArgumentNullException("Items added to a SocketAsyncEventArgsPool cannot be null");
24             }
25             lock (this.m_pool)
26             {
27                 this.m_pool.Push(item);
28             }
29         }
30 
31         public SocketAsyncEventArgs Pop()
32         {
33             SocketAsyncEventArgs result;
34             lock (this.m_pool)
35             {
36                 result = this.m_pool.Pop();
37             }
38             return result;
39         }
40 
41         public int Count
42         {
43             get
44             {
45                 return this.m_pool.Count;
46             }
47         }
48     }
49 }

  1 using System;
  2 using System.Net;
  3 using System.Net.Sockets;
  4 using System.Text;
  5 using System.Threading;
  6 
  7 namespace JCommon.Net
  8 {
  9     public class SocketClient
 10     {
 11         public event EventHandler<SocketAsyncEventArgs> OnReceived;
 12         public event EventHandler<SocketAsyncEventArgs> OnSendCompleted;
 13         public event EventHandler<SocketAsyncEventArgs> OnConnectCompleted;
 14         public event EventHandler<SocketAsyncEventArgs> OnConnectionClosed;
 15 
 16         private Socket sock;
 17         private byte[] sendBuffer;
 18         private int receiveBufferCapacity;
 19         private int writeBufferCapacity;
 20         private SocketAsyncEventArgs readArgs = new SocketAsyncEventArgs();
 21         private SocketAsyncEventArgs writeArgs = new SocketAsyncEventArgs();
 22         private SocketAsyncEventArgs connectArgs;
 23         private AutoResetEvent sendCompletedEvent = new AutoResetEvent(false);
 24         private object sync_disconn = new object();
 25         private byte[] receiveBuffer;
 26 
 27         public SocketClient(int receiveCapacity = 1024, int sendCapacity = 256)
 28         {
 29             this.receiveBufferCapacity = receiveCapacity;
 30             this.writeBufferCapacity = sendCapacity;
 31             this.sock = new Socket(SocketType.Stream, ProtocolType.Tcp);
 32             this.receiveBuffer = new byte[receiveCapacity];
 33             this.readArgs.SetBuffer(this.receiveBuffer, 0, receiveCapacity);
 34             this.readArgs.Completed += this.IO_Completed;
 35             this.readArgs.UserToken = new AsyncUserToken
 36             {
 37                 Socket = this.sock
 38             };
 39             this.sendBuffer = new byte[sendCapacity];
 40             this.writeArgs.SetBuffer(this.sendBuffer, 0, sendCapacity);
 41             this.writeArgs.Completed += this.IO_Completed;
 42             this.writeArgs.UserToken = new AsyncUserToken
 43             {
 44                 Socket = this.sock
 45             };
 46         }
 47 
 48         ~SocketClient()
 49         {
 50             this.Disconnect(false);
 51         }
 52 
 53         public bool Connect(bool block = true)
 54         {
 55             if (this.sock != null && this.sock.Connected)
 56             {
 57                 return true;
 58             }
 59             if (this.sock == null)
 60             {
 61                 this.sock = new Socket(SocketType.Stream, ProtocolType.Tcp);
 62                 this.readArgs = new SocketAsyncEventArgs();
 63                 this.readArgs.SetBuffer(this.receiveBuffer, 0, this.receiveBufferCapacity);
 64                 this.readArgs.Completed += this.IO_Completed;
 65                 this.readArgs.UserToken = new AsyncUserToken
 66                 {
 67                     Socket = this.sock
 68                 };
 69                 this.writeArgs = new SocketAsyncEventArgs();
 70                 this.writeArgs.SetBuffer(this.sendBuffer, 0, this.writeBufferCapacity);
 71                 this.writeArgs.Completed += this.IO_Completed;
 72                 this.writeArgs.UserToken = new AsyncUserToken
 73                 {
 74                     Socket = this.sock
 75                 };
 76             }
 77             if (block)
 78             {
 79                 this.sock.Connect(this.ServerIP, this.ServerPort);
 80                 if (this.sock.Connected)
 81                 {
 82                     // TCP客户端开始接受服务器发送的数据
 83                     this.readArgs.SetBuffer(0, this.receiveBufferCapacity);
 84                     if (!this.sock.ReceiveAsync(this.readArgs))
 85                     {
 86                         this.ProcessReceive(this.readArgs);
 87                     }
 88                 }
 89             }
 90             else
 91             {
 92                 this.connectArgs = new SocketAsyncEventArgs();
 93                 this.connectArgs.Completed += this.IO_Completed;
 94                 this.connectArgs.UserToken = new AsyncUserToken
 95                 {
 96                     Socket = this.sock
 97                 };
 98                 this.connectArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(this.ServerIP), this.ServerPort);
 99                 if (!this.sock.ConnectAsync(this.connectArgs))
100                 {
101                     this.ProcessConnect(this.connectArgs);
102                 }
103             }
104             return this.sock.Connected;
105         }
106 
107         /// <summary>
108         /// 关闭连接
109         /// </summary>
110         /// <param name="reuseSocket">如果关闭套接字允许重用套接字则为true</param>
111         public void Disconnect(bool reuseSocket)
112         {
113             if (this.sock == null)
114             {
115                 return;
116             }
117             if (this.sock.Connected)
118             {
119                 try
120                 {
121                     lock (this.sync_disconn)
122                     {
123                         this.sock.Shutdown(SocketShutdown.Both);
124                         this.sock.Disconnect(reuseSocket);
125                         this.sock.Close();
126                         this.sock = null;
127                     }
128                 }
129                 catch (SocketException)
130                 {
131                     this.sock = null;
132                 }
133                 catch (Exception)
134                 {
135                     this.sock = null;
136                 }
137             }
138         }
139 
140         public int Send(byte[] buffer)
141         {
142             if (this.sock == null || !this.sock.Connected)
143             {
144                 return 0;
145             }
146             return this.sock.Send(buffer);
147         }
148 
149         /// <summary>
150         /// 发送
151         /// </summary>
152         /// <param name="data">要发送的字符串</param>
153         /// <param name="bBlock">阻塞发送</param>
154         /// <returns></returns>
155         public int Send(string data, bool bBlock = true)
156         {
157             byte[] bytes = Encoding.Default.GetBytes(data);
158             if (bBlock)
159             {
160                 return this.sock.Send(bytes);
161             }
162             if (bytes.Length > this.writeBufferCapacity)
163             {
164                 this.writeBufferCapacity = bytes.Length;
165                 this.sendBuffer = new byte[this.writeBufferCapacity];
166             }
167             Array.Copy(bytes, this.sendBuffer, bytes.Length);
168             this.writeArgs.SetBuffer(0, bytes.Length);
169             if (!this.sock.SendAsync(this.writeArgs))
170             {
171                 this.ProcessSend(this.writeArgs);
172             }
173             return 0;
174         }
175 
176         private void IO_Completed(object sender, SocketAsyncEventArgs e)
177         {
178             SocketAsyncOperation lastOperation = e.LastOperation;
179             switch (lastOperation)
180             {
181             case SocketAsyncOperation.Connect:
182                 this.ProcessConnect(e);
183                 return;
184             case SocketAsyncOperation.Disconnect:
185                 break;
186             case SocketAsyncOperation.Receive:
187                 this.ProcessReceive(e);
188                 return;
189             default:
190                 if (lastOperation == SocketAsyncOperation.Send)
191                 {
192                     this.ProcessSend(e);
193                     return;
194                 }
195                 break;
196             }
197             throw new ArgumentException("The last operation completed on the socket was not a receive or send");
198         }
199 
200         /// <summary>
201         /// 处理接收到的数据
202         /// </summary>
203         /// <param name="e"></param>
204         private void ProcessReceive(SocketAsyncEventArgs e)
205         {
206             AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
207             if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
208             {
209                 if (this.OnReceived != null)
210                 {
211                     this.OnReceived(this, e);
212                 }
213                 e.SetBuffer(e.Offset, this.receiveBufferCapacity);
214                 if (!asyncUserToken.Socket.ReceiveAsync(e))
215                 {
216                     this.ProcessReceive(e);
217                     return;
218                 }
219             }
220             else
221             {
222                 this.CloseClientSocket(e);
223             }
224         }
225 
226         /// <summary>
227         /// 发送完成后调用
228         /// </summary>
229         /// <param name="e"></param>
230         private void ProcessSend(SocketAsyncEventArgs e)
231         {
232             if (e.SocketError == SocketError.Success)
233             {
234                 if (this.OnSendCompleted != null)
235                 {
236                     this.OnSendCompleted(this, e);
237                     return;
238                 }
239             }
240             else
241             {
242                 this.CloseClientSocket(e);
243             }
244         }
245 
246         private void ProcessConnect(SocketAsyncEventArgs e)
247         {
248             if (e.SocketError == SocketError.Success)
249             {
250                 if (this.OnConnectCompleted != null)
251                 {
252                     this.OnConnectCompleted(this, e);
253                 }
254 
255                 this.readArgs.SetBuffer(0, this.receiveBufferCapacity);
256                 if (!this.sock.ReceiveAsync(this.readArgs))
257                 {
258                     this.ProcessReceive(this.readArgs);
259                     return;
260                 }
261             }
262             else if (e.SocketError == SocketError.ConnectionRefused || e.SocketError == SocketError.HostUnreachable || e.SocketError == SocketError.TimedOut)
263             {
264                 if (this.OnConnectCompleted != null)
265                 {
266                     this.OnConnectCompleted(this, e);
267                     return;
268                 }
269             }
270             else
271             {
272                 this.CloseClientSocket(e);
273             }
274         }
275 
276         private void CloseClientSocket(SocketAsyncEventArgs e)
277         {
278             if (this.OnConnectionClosed != null)
279             {
280                 this.OnConnectionClosed(this, e);
281             }
282             AsyncUserToken asyncUserToken = e.UserToken as AsyncUserToken;
283             try
284             {
285                 lock (this.sync_disconn)
286                 {
287                     if (this.sock != null)
288                     {
289                         this.sock.Shutdown(SocketShutdown.Send);
290                         this.sock.Close(200);
291                         this.sock = null;
292                     }
293                 }
294             }
295             catch (Exception){}
296             asyncUserToken.Socket = null;
297         }
298 
299         private void Dispose()
300         {
301             try
302             {
303                 // 关闭socket时，单独使用socket.close()通常会造成资源提前被释放，
304                 // 应该在关闭socket之前，先使用shutdown进行接受或者发送的禁用，再使用socket进行释放
305                 this.sock.Shutdown(SocketShutdown.Both);
306                 this.sock.Close();
307                 this.sock.Dispose();
308                 this.sock = null;
309             }
310             catch (Exception){}
311         }
312 
313         public string ServerIP { get; set; }
314 
315         public int ServerPort { get; set; }
316 
317         public byte[] ReceiveBuffer
318         {
319             get
320             {
321                 return this.receiveBuffer;
322             }
323         }
324 
325         public bool Connected
326         {
327             get
328             {
329                 return this.sock != null && this.sock.Connected;
330             }
331         }
332     }
333 }

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Net;
  4 using System.Net.Sockets;
  5 using System.Threading;
  6 
  7 namespace JCommon.Net
  8 {
  9     public class SocketServer
 10     {
 11         public event EventHandler<SocketAsyncEventArgs> OnReceiveCompleted;
 12         public event EventHandler<SocketAsyncEventArgs> OnSendCompleted;
 13         public event EventHandler<SocketAsyncEventArgs> OnAccept;
 14         public event EventHandler<SocketAsyncEventArgs> OnConnectionBreak;
 15 
 16         private const int opsToPreAlloc = 2;                // 读，写（不为 接受连接 accepts 分配缓冲区空间）
 17         private int m_numConnections;                       // 同时处理的最大连接数
 18         private int m_receiveBufferSize;                    // 用于每个Socket I/O 操作的缓冲区大小
 19         private BufferManager m_bufferManager;              // 表示用于所有套接字操作的大量可重用的缓冲区
 20         private Socket listenSocket;                        // 用于监听传入的连接请求的套接字
 21         private SocketAsyncEventArgsPool m_readWritePool;   // 可重用SocketAsyncEventArgs对象池，用于写入，读取和接受套接字操作
 22         private List<SocketAsyncEventArgs> m_connectedPool;
 23         private int m_totalBytesRead;                       // 服务器接收的总共＃个字节的计数器
 24         private int m_numConnectedSockets;                  // 连接到服务器的客户端总数
 25         private Semaphore m_maxNumberAcceptedClients;
 26 
 27         /// <summary>
 28         /// 创建服务端实例
 29         /// </summary>
 30         /// <param name="numConnections"></param>
 31         /// <param name="receiveBufferSize"></param>
 32         public SocketServer(int numConnections, int receiveBufferSize)
 33         {
 34             this.m_totalBytesRead = 0;
 35             this.m_numConnectedSockets = 0;
 36             this.m_numConnections = numConnections;
 37             this.m_receiveBufferSize = receiveBufferSize;
 38             this.m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc, receiveBufferSize);
 39             this.m_readWritePool = new SocketAsyncEventArgsPool(numConnections);
 40             this.m_connectedPool = new List<SocketAsyncEventArgs>(numConnections);
 41         }
 42 
 43         /// <summary>
 44         /// 分配 SocketAsyncEventArg 对象池
 45         /// </summary>
 46         public void Init()
 47         {
 48             // 分配一个大字节缓冲区，所有 I/O 操作都使用该缓冲区。
 49             this.m_bufferManager.InitBuffer();
 50             for (int i = 0; i < this.m_numConnections; i++)
 51             {
 52                 // 分配可重用的 SocketAsyncEventArgs 对象
 53                 SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs();
 54                 socketAsyncEventArgs.Completed += this.IO_Completed;
 55                 socketAsyncEventArgs.UserToken = new AsyncUserToken();
 56 
 57                 // 将缓冲池中的字节缓冲区分配给 SocketAsyncEventArg 对象
 58                 this.m_bufferManager.SetBuffer(socketAsyncEventArgs);
 59 
 60                 // 放入对象池
 61                 this.m_readWritePool.Push(socketAsyncEventArgs);
 62             }
 63         }
 64 
 65         /// <summary>
 66         /// 启动服务器，侦听客户端连接请求
 67         /// </summary>
 68         /// <param name="localEndPoint"></param>
 69         public void Start(IPEndPoint localEndPoint)
 70         {
 71             try
 72             {
 73                 // 限制最大连接数
 74                 this.m_maxNumberAcceptedClients = new Semaphore(this.m_numConnections, this.m_numConnections);
 75 
 76                 // 创建 Socket 监听连接请求
 77                 this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 78                 this.listenSocket.Bind(localEndPoint);
 79                 this.listenSocket.Listen(10);
 80 
 81                 // 接受客户端连接请求
 82                 this.StartAccept(null);
 83             }
 84             catch (Exception){}
 85         }
 86 
 87         public void Stop()
 88         {
 89             if (this.listenSocket == null)
 90             {
 91                 return;
 92             }
 93             try
 94             {
 95                 lock(m_connectedPool)
 96                 {
 97                     for (int i = 0; i < this.m_connectedPool.Count; i++)
 98                     {
 99                         this.CloseClientSocket(m_connectedPool[i]);
100                     }
101                     this.m_connectedPool.Clear();
102                 }
103                 this.listenSocket.LingerState = new LingerOption(true, 0);
104                 this.listenSocket.Close();
105                 this.listenSocket.Dispose();
106                 this.listenSocket = null;
107                 GC.Collect();
108             }
109             catch (Exception)
110             {
111             }
112         }
113 
114         public void Send(AsyncUserToken arg, byte[] msg)
115         {
116            SocketAsyncEventArgs argSend =  this.m_connectedPool.Find((s) => {
117                 AsyncUserToken userToken = s.UserToken as AsyncUserToken;
118                 return userToken.EndPort.ToString() == arg.EndPort.ToString();
119             });
120 
121            AsyncUserToken userToken1 = argSend.UserToken as AsyncUserToken;
122            userToken1.Socket.Send(msg);
123         }
124 
125         public void SendToAll(byte[] msg)
126         {
127             foreach(SocketAsyncEventArgs arg in this.m_connectedPool)
128             {
129                 AsyncUserToken userToken = arg.UserToken as AsyncUserToken;
130                 userToken.Socket.Send(msg);
131             }
132         }
133 
134         /// <summary>
135         /// 开始接受来自客户端的连接请求
136         /// </summary>
137         /// <param name="acceptEventArg"></param>
138         private void StartAccept(SocketAsyncEventArgs acceptEventArg)
139         {
140             if (acceptEventArg == null)
141             {
142                 acceptEventArg = new SocketAsyncEventArgs();
143                 acceptEventArg.Completed += this.AcceptEventArg_Completed;
144             }
145             else
146             {
147                 acceptEventArg.AcceptSocket = null;
148             }
149             this.m_maxNumberAcceptedClients.WaitOne();
150             if (this.listenSocket == null)
151             {
152                 return;
153             }
154             if (!this.listenSocket.AcceptAsync(acceptEventArg))
155             {
156                 this.ProcessAccept(acceptEventArg);
157             }
158         }
159 
160         /// <summary>
161         /// 接受连接请求完成后回调
162         /// </summary>
163         /// <param name="sender"></param>
164         /// <param name="e"></param>
165         private void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
166         {
167             this.ProcessAccept(e);
168         }
169 
170         private void ProcessAccept(SocketAsyncEventArgs e)
171         {
172             if (e.SocketError == SocketError.Success)
173             {
174                 Interlocked.Increment(ref this.m_numConnectedSockets);
175                 if (this.OnAccept != null)
176                 {
177                     this.OnAccept(null, e);
178                 }
179 
180                 // 获取接受的客户端连接的套接字
181                 SocketAsyncEventArgs socketAsyncEventArgs = this.m_readWritePool.Pop();
182                 AsyncUserToken userToken = socketAsyncEventArgs.UserToken as AsyncUserToken;
183                 userToken.Socket = e.AcceptSocket;
184                 userToken.ConnectTime = DateTime.Now;
185                 userToken.EndPort = e.AcceptSocket.RemoteEndPoint as IPEndPoint;
186 
187                 lock (m_connectedPool)
188                 {
189                     this.m_connectedPool.Add(socketAsyncEventArgs);
190                 }
191 
192                 if (!e.AcceptSocket.ReceiveAsync(socketAsyncEventArgs))
193                 {
194                     this.ProcessReceive(socketAsyncEventArgs);
195                 }
196 
197                 // 接受下一个连接请求
198                 this.StartAccept(e);
199             }
200             else
201             {
202                 this.Stop();
203             }
204         }
205 
206         /// <summary>
207         /// 每当套接字上的接收或发送操作完成时，就会调用此方法
208         /// </summary>
209         /// <param name="sender"></param>
210         /// <param name="e"></param>
211         private void IO_Completed(object sender, SocketAsyncEventArgs e)
212         {
213             switch (e.LastOperation)
214             {
215                 case SocketAsyncOperation.Receive:
216                     ProcessReceive(e);
217                     break;
218                 case SocketAsyncOperation.Send:
219                     ProcessSend(e);
220                     break;
221                 default:
222                     throw new ArgumentException("The last operation completed on the socket was not a receive or send");
223             }      
224         }
225 
226         /// <summary>
227         /// 异步接收操作完成后，将调用此方法。
228         /// </summary>
229         /// <param name="e"></param>
230         private void ProcessReceive(SocketAsyncEventArgs e)
231         {
232             AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
233             if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
234             {
235                 Interlocked.Add(ref this.m_totalBytesRead, e.BytesTransferred);
236                 if (this.OnReceiveCompleted != null)
237                 {
238                     this.OnReceiveCompleted(this, e);
239                 }
240                 e.SetBuffer(e.Offset, this.m_receiveBufferSize);
241                 if (!asyncUserToken.Socket.ReceiveAsync(e))
242                 {
243                     this.ProcessReceive(e);
244                     return;
245                 }
246             }
247             else
248             {
249                 this.CloseClientSocket(e);
250             }
251         }
252 
253         /// <summary>
254         /// 异步发送操作完成后，将调用此方法。
255         /// 该方法在套接字上发出另一个接收，以读取从客户端发送的所有其他数据
256         /// </summary>
257         /// <param name="e"></param>
258         private void ProcessSend(SocketAsyncEventArgs e)
259         {
260             if (e.SocketError == SocketError.Success)
261             {
262                 if (this.OnSendCompleted != null)
263                 {
264                     this.OnSendCompleted(null, e);
265                 }
266                 AsyncUserToken asyncUserToken = (AsyncUserToken)e.UserToken;
267                 if (!asyncUserToken.Socket.ReceiveAsync(e))
268                 {
269                     this.ProcessReceive(e);
270                     return;
271                 }
272             }
273             else
274             {
275                 this.CloseClientSocket(e);
276             }
277         }
278 
279         private void CloseClientSocket(SocketAsyncEventArgs e)
280         {
281             if (this.OnConnectionBreak != null)
282             {
283                 this.OnConnectionBreak(null, e);
284             }
285             AsyncUserToken asyncUserToken = e.UserToken as AsyncUserToken;
286             if (asyncUserToken != null && asyncUserToken.Socket != null)
287             {
288                 try
289                 {
290                     asyncUserToken.Socket.Shutdown(SocketShutdown.Both);
291                     asyncUserToken.Socket.Disconnect(false);
292                     asyncUserToken.Socket.Close();
293                     asyncUserToken.Socket = null;
294                 }
295                 catch (Exception)
296                 {
297                 }
298                 finally
299                 {
300                     Interlocked.Decrement(ref this.m_numConnectedSockets);
301                     this.m_maxNumberAcceptedClients.Release();
302                     this.m_readWritePool.Push(e);
303                     lock (m_connectedPool)
304                     {
305                         this.m_connectedPool.Remove(e);
306                     }
307                 }
308             }
309         }
310     }
311 }