zoukankan      html  css  js  c++  java
  • 使用完成端口(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 }
  • 相关阅读:
    L1范式和L2范式的区别
    随机森林
    LDA-math-神奇的Gamma函数
    (转)共轭先验的理解
    Hits算法
    朴素贝叶斯分类算法(3)
    朴素贝叶斯分类算法(2)
    朴素贝叶斯分类算法(1)
    多项分布(multinominal distribution)
    从对偶问题到KKT条件
  • 原文地址:https://www.cnblogs.com/jshchg/p/12931668.html
Copyright © 2011-2022 走看看