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();
}
}