private void ProcessAccept(SocketAsyncEventArgs acceptEventArgs)
{
App.Logger.Info("Client connection accepted. Local Address: {0}, Remote Address: {1}",
acceptEventArgs.AcceptSocket.LocalEndPoint, acceptEventArgs.AcceptSocket.RemoteEndPoint);
AsyncSocketUserToken userToken = AsyncSocketUserTokenPool.Pop();
AsyncSocketUserTokenList.Add(userToken); //添加到正在连接列表
userToken.ConnectSocket = acceptEventArgs.AcceptSocket;
userToken.ConnectDateTime = DateTime.Now;
try
{
bool willRaiseEvent = userToken.ConnectSocket.ReceiveAsync(userToken.ReceiveEventArgs); //投递接收请求
if (!willRaiseEvent)
{
lock (userToken)
{
ProcessReceive(userToken.ReceiveEventArgs);
}
}
}
catch (Exception E)
{
App.Logger.Error("Accept client {0} error, message: {1}", userToken.ConnectSocket, E.Message);
App.Logger.Error(E.StackTrace);
}
StartAccept(acceptEventArgs); //把当前异步事件释放，等待下次连接
}
private void ProcessAccept(SocketAsyncEventArgs acceptEventArgs)
{
Console.WriteLine("Client connection accepted. Local Address: {0}, Remote Address: {1}",
acceptEventArgs.AcceptSocket.LocalEndPoint, acceptEventArgs.AcceptSocket.RemoteEndPoint);
AsyncSocketUserToken userToken = AsyncSocketUserTokenPool.Pop();
AsyncSocketUserTokenList.Add(userToken);
userToken.ConnectSocket = acceptEventArgs.AcceptSocket;
userToken.ConnectDateTime = DateTime.Now;
try
{
bool willRaiseEvent = userToken.ConnectSocket.ReceiveAsync(userToken.ReceiveEventArgs);
if (!willRaiseEvent)
{
lock (userToken)
{
ProcessReceive(userToken.ReceiveEventArgs);
}
}
}
catch (Exception E)
{
Console.WriteLine("Accept client {0} error, message: {1}", userToken.ConnectSocket, E.Message);
Console.WriteLine(E.StackTrace);
}
StartAccept(acceptEventArgs);
}
public virtual void CloseSocket(AsyncUserToken iSocketToken)
{
if (iSocketToken.Socket == null)
{
return;
}
string socketInfo = string.Format("Local Address: {0} Remote Address: {1}", iSocketToken.Socket.LocalEndPoint,
iSocketToken.SendEventArgs.RemoteEndPoint);
App.Logger.Info("Connection disconnected. {0}", socketInfo);
try
{
iSocketToken.Socket.Shutdown(SocketShutdown.Both);
}
catch (Exception e)
{
App.Logger.Info("CloseSocket Disconnect {0} error, message: {1}", socketInfo, e.Message);
}
iSocketToken.Socket.Close();
iSocketToken.Socket = null; //释放引用，并清理缓存，包括释放协议对象等资源
iSocketToken.Clear();
AsyncSocketUserTokenUsed.Remove(iSocketToken.OwnerID1);
AsyncSocketUserTokenPool.Push(iSocketToken);
MaxNumberAccepted.Release();
}
private void ProcessAccept(SocketAsyncEventArgs iSocketAsyncEventArgs)
{
if (iSocketAsyncEventArgs.SocketError == SocketError.Success)
{
App.Logger.Info("Client connection accepted. Local Address: {0}, Remote Address: {1}",
iSocketAsyncEventArgs.AcceptSocket.LocalEndPoint, iSocketAsyncEventArgs.AcceptSocket.RemoteEndPoint);
AsyncUserToken oSocketToken = AsyncSocketUserTokenPool.Pop();
AsyncSocketUserTokenUsed.Add(oSocketToken.OwnerID1, oSocketToken); //添加到正在连接列表
oSocketToken.Socket = iSocketAsyncEventArgs.AcceptSocket;
oSocketToken.ConnectDateTime = DateTime.Now;
try
{
bool willRaiseEvent = oSocketToken.Socket.ReceiveAsync(oSocketToken.RecvEventArgs); //投递接收请求
if (!willRaiseEvent)
{
OnRecvAsync(oSocketToken.RecvEventArgs);
}
}
catch (Exception e)
{
App.Logger.Error("Accept client {0} error, message: {1}", oSocketToken.Socket, e.Message);
App.Logger.Error(e.StackTrace);
}
}
StartAccept(iSocketAsyncEventArgs); //把当前异步事件释放，等待下次连接
}
public virtual void CloseSocket(AsyncUserToken socketToken)
{
if (socketToken.Socket == null)
{
return;
}
string socketInfo = string.Format("本地地址: {0} 远程地址: {1}", socketToken.Socket.LocalEndPoint,
socketToken.Socket.RemoteEndPoint);
try
{
socketToken.Socket.Shutdown(SocketShutdown.Both);
App.Info("关闭连接. {0}", socketInfo);
}
catch (Exception e)
{
App.Info("关闭连接 {0} 错误, 消息: {1}", socketInfo, e.Message);
}
socketToken.Socket.Close();
socketToken.Socket = null; //释放引用，并清理缓存，包括释放协议对象等资源
socketToken.Clear();
AsyncSocketUserTokenUsed.Remove(socketToken);
AsyncSocketUserTokenPool.Push(socketToken);
MaxNumberAccepted.Release();
Closed?.Invoke(socketToken); // 连接关闭回调
}
private void ProcessAccept(SocketAsyncEventArgs eventArgs)
{
if (eventArgs.SocketError == SocketError.Success)
{
App.Info("客户端已连接. 本地地址: {0}, 远程地址: {1}",
eventArgs.AcceptSocket.LocalEndPoint, eventArgs.AcceptSocket.RemoteEndPoint);
AsyncUserToken socketToken = AsyncSocketUserTokenPool.Pop();
AsyncSocketUserTokenUsed.Add(socketToken); //添加到正在连接列表
socketToken.Socket = eventArgs.AcceptSocket;
socketToken.ConnectDateTime = DateTime.Now;
Connected?.Invoke(socketToken); // 连接回调
try
{
bool willRaiseEvent = socketToken.Socket.ReceiveAsync(socketToken.RecvEventArgs); //投递接收请求
if (!willRaiseEvent)
{
OnRecvAsync(socketToken.RecvEventArgs);
}
}
catch (Exception e)
{
App.Error("接收客户端连接 {0} 错误, 消息: {1}", socketToken.Socket, e.Message);
}
}
StartAccept(eventArgs); //把当前异步事件释放，等待下次连接
}
public void CloseSocket(AsyncSocketUserToken userToken)
{
if (userToken.ConnectSocket == null)
{
return;
}
string socketInfo = string.Format("Local Address: {0} Remote Address: {1}", userToken.ConnectSocket.LocalEndPoint,
userToken.SendEventArgs.RemoteEndPoint);
App.Logger.Info("Connection disconnected. {0}", socketInfo);
try
{
userToken.ConnectSocket.Shutdown(SocketShutdown.Both);
}
catch (Exception E)
{
App.Logger.Info("CloseSocket Disconnect {0} error, message: {1}", socketInfo, E.Message);
}
userToken.ConnectSocket.Close();
userToken.ConnectSocket = null; //释放引用，并清理缓存，包括释放协议对象等资源
userToken.TokenClose();
MaxNumberAccepted.Release();
AsyncSocketUserTokenPool.Push(userToken);
AsyncSocketUserTokenList.Remove(userToken);
}
public AsyncSocketServer(int numConnections)
{
m_numConnections = numConnections;
m_receiveBufferSize = ProtocolConst.ReceiveBufferSize;
m_asyncSocketUserTokenPool = new AsyncSocketUserTokenPool(numConnections);
m_asyncSocketUserTokenList = new AsyncSocketUserTokenList();
m_maxNumberAcceptedClients = new Semaphore(numConnections, numConnections);
}
public SocketClient() : base(1)
{
UserToken = AsyncSocketUserTokenPool.Pop();
AsyncSocketUserTokenList.Add(UserToken);
}
