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 }