void ProcessAccept(SocketAsyncEventArgs se) { if (!Active || Client == null) { se.TryDispose(); return; } // 判断成功失败 if (se.SocketError != SocketError.Success) { // 未被关闭Socket时,可以继续使用 //if (!se.IsNotClosed()) { var ex = se.GetException(); if (ex != null) { OnError("AcceptAsync", ex); } se.TryDispose(); return; } } else { // 直接在IO线程调用业务逻辑 try { // 估算完成时间,执行过长时提示 using (var tc = new TimeCost("{0}.OnAccept".F(GetType().Name), 200)) { tc.Log = Log; OnAccept(se.AcceptSocket); } } catch (Exception ex) { if (!ex.IsDisposed()) { OnError("EndAccept", ex); } } finally { se.AcceptSocket = null; } } // 开始新的征程 AcceptAsync(se, true); }
Boolean ReceiveAsync(SocketAsyncEventArgs se, Boolean io) { if (Disposed) { Interlocked.Decrement(ref _RecvCount); se.TryDispose(); throw new ObjectDisposedException(GetType().Name); } var rs = false; try { // 开始新的监听 rs = OnReceiveAsync(se); } catch (Exception ex) { Interlocked.Decrement(ref _RecvCount); se.TryDispose(); if (!ex.IsDisposed()) { OnError("ReceiveAsync", ex); // 异常一般是网络错误,UDP不需要关闭 if (!io && ThrowException) { throw; } } return(false); } // 如果当前就是异步线程,直接处理,否则需要开任务处理,不要占用主线程 if (!rs) { if (io) { ProcessReceive(se); } else { Task.Factory.StartNew(() => ProcessReceive(se)); } } return(true); }
public static async Task <int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int count) { var tcs = new TaskCompletionSource <int>(); var args = new SocketAsyncEventArgs(); try { args.SetBuffer(buffer, offset, count); args.Completed += (s, e) => tcs.TrySetResult(e.BytesTransferred); var isAsync = socket.ReceiveAsync(args); if (!isAsync) { tcs.TrySetResult(args.BytesTransferred); } return(await tcs.Task); } catch { throw; } finally { args.TryDispose(); } }
void ReleaseSend(String reason) { _seSend.TryDispose(); _seSend = null; if (Log != null && Log.Level <= LogLevel.Debug) { WriteLog("释放SendSA {0} {1}", 1, reason); } }
void ReleaseRecv(SocketAsyncEventArgs se, String reason) { var idx = (Int32)se.UserToken; if (Log != null && Log.Level <= LogLevel.Debug) { WriteLog("释放RecvSA {0} {1}", idx, reason); } Interlocked.Decrement(ref _RecvCount); se.TryDispose(); }
void ProcessSend(SocketAsyncEventArgs se) { if (!Active) { se.TryDispose(); return; } // 判断成功失败 if (se.SocketError != SocketError.Success) { // 未被关闭Socket时,可以继续使用 //if (!se.IsNotClosed()) { var ex = se.GetException(); if (ex != null) { OnError("SendAsync", ex); } se.TryDispose(); //if (se.SocketError == SocketError.ConnectionReset) Dispose(); if (se.SocketError == SocketError.ConnectionReset) { Close("SendAsync " + se.SocketError); } return; } } // 发送新的数据 if (Interlocked.CompareExchange(ref _Sending, 0, 1) == 1) { CheckSendQueue(true); } }
/// <summary>开启异步接受新连接</summary> /// <param name="se"></param> /// <param name="io">是否IO线程</param> /// <returns>开启异步是否成功</returns> Boolean AcceptAsync(SocketAsyncEventArgs se, Boolean io) { if (!Active || Client == null) { se.TryDispose(); return(false); } var rs = false; try { //_Async = Server.BeginAcceptTcpClient(OnAccept, null); rs = Client.AcceptAsync(se); } catch (Exception ex) { if (!ex.IsDisposed()) { OnError("AcceptAsync", ex); } if (!io) { throw; } return(false); } if (!rs) { if (io) { ProcessAccept(se); } else { Task.Factory.StartNew(() => ProcessAccept(se)); } } return(true); }
private void OnCleanup() { if (_disposed) { return; } _disposed = _shouldDispose = true; _other._shouldDispose = true; _other = null; _source.TryDispose(); _target.TryDispose(); _recSaea.TryDispose(); _sendSaea.TryDispose(); _source = _target = null; _recSaea = _sendSaea = null; _buffer = null; }
private void OnCleanup() { if (Disposed) { return; } Disposed = ShouldDispose = true; Other.ShouldDispose = true; Other = null; Source.TryDispose(); Target.TryDispose(); RecSAEA.TryDispose(); SendSAEA.TryDispose(); Source = Target = null; RecSAEA = SendSAEA = null; Buffer = null; }
void ProcessReceive(SocketAsyncEventArgs se) { if (!Active) { se.TryDispose(); return; } // 判断成功失败 if (se.SocketError != SocketError.Success) { // 未被关闭Socket时,可以继续使用 //if (!se.IsNotClosed()) if (OnReceiveError(se)) { var ex = se.GetException(); if (ex != null) { OnError("ReceiveAsync", ex); } se.TryDispose(); return; } } else { // 拷贝走数据,参数要重复利用 var data = se.Buffer.ReadBytes(se.Offset, se.BytesTransferred); var ep = se.RemoteEndPoint as IPEndPoint; // 在用户线程池里面去处理数据 //Task.Factory.StartNew(() => OnReceive(data, ep)).LogException(ex => OnError("OnReceive", ex)); //ThreadPool.QueueUserWorkItem(s => OnReceive(data, ep)); // 直接在IO线程调用业务逻辑 try { // 估算完成时间,执行过长时提示 using (var tc = new TimeCost("{0}.OnReceive".F(GetType().Name), 1000)) { tc.Log = Log; OnReceive(data, ep); } } catch (Exception ex) { if (!ex.IsDisposed()) { OnError("OnReceive", ex); } } } // 开始新的监听 if (Active && !Disposed) { ReceiveAsync(se, true); } else { se.TryDispose(); } }