private void AcceptAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
Socket socket = null;
try
{
socket = e.AcceptSocket;
socket.SendBufferSize = BaseServer.SEND_BUFF_SIZE;
BaseClient newClient = this.GetNewClient();
try
{
if (BaseServer.log.IsInfoEnabled)
{
string str = socket.Connected ? socket.RemoteEndPoint.ToString() : "socket disconnected";
BaseServer.log.Info("Incoming connection from " + str);
}
object syncRoot;
Monitor.Enter(syncRoot = this._clients.SyncRoot);
try
{
this._clients.Add(newClient, newClient);
newClient.Disconnected += new ClientEventHandle(this.client_Disconnected);
}
finally
{
Monitor.Exit(syncRoot);
}
newClient.Connect(socket);
newClient.ReceiveAsync();
}
catch (Exception arg)
{
BaseServer.log.ErrorFormat("create client failed:{0}", arg);
newClient.Disconnect();
}
}
catch
{
if (socket != null)
{
try
{
socket.Close();
}
catch
{
}
}
}
finally
{
e.Dispose();
this.AcceptAsync();
}
}
private void AcceptAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
Socket sock = null;
try
{
sock = e.AcceptSocket;
sock.SendBufferSize = BaseServer.SEND_BUFF_SIZE;
BaseClient client = this.GetNewClient();
try
{
string ip = sock.Connected ? sock.RemoteEndPoint.ToString() : "socket disconnected";
BaseServer.log.Debug("Incoming connection from " + ip);
object syncRoot;
Monitor.Enter(syncRoot = this._clients.SyncRoot);
try
{
this._clients.Add(client, client);
client.Disconnected += new ClientEventHandle(this.client_Disconnected);
}
finally
{
Monitor.Exit(syncRoot);
}
client.Connect(sock);
client.ReceiveAsync();
}
catch (Exception ex)
{
BaseServer.log.ErrorFormat("create client failed:{0}", ex);
client.Disconnect();
}
}
catch
{
if (sock != null)
{
try
{
sock.Close();
}
catch
{
}
}
}
finally
{
e.Dispose();
this.AcceptAsync();
}
}
/// <summary>
/// Accepts complete event's callback funciton.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AcceptAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
Socket sock = null;
try
{
sock = e.AcceptSocket;
sock.SendBufferSize = SEND_BUFF_SIZE;
BaseClient client = GetNewClient();
//TrieuLSL
try
{
if (log.IsInfoEnabled)
{
string ip = sock.Connected ? sock.RemoteEndPoint.ToString() : "socket disconnected";
log.Info("Incoming connection from " + ip);
}
lock (_clients.SyncRoot)
{
_clients.Add(client, client);//Add the client instance to a hy dictionary.
client.Disconnected += client_Disconnected;
}
client.Connect(sock);
client.ReceiveAsync();
}
catch (Exception ex)
{
log.ErrorFormat("create client failed:{0}", ex);
client.Disconnect();
}
}
catch
{
if (sock != null) // don't leave the socket open on exception
{
try { sock.Close(); }
catch { }
}
}
finally
{
e.Dispose();
AcceptAsync();
}
}
private void AcceptAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
Socket connectedSocket = null;
try
{
connectedSocket = e.AcceptSocket;
connectedSocket.SendBufferSize = SEND_BUFF_SIZE;
BaseClient newClient = this.GetNewClient();
try
{
if (log.IsInfoEnabled)
{
log.Info("Incoming connection from " + (connectedSocket.Connected ? connectedSocket.RemoteEndPoint.ToString() : "socket disconnected"));
}
lock (this._clients.SyncRoot)
{
this._clients.Add(newClient, newClient);
newClient.Disconnected += new ClientEventHandle(this.client_Disconnected);
}
newClient.Connect(connectedSocket);
newClient.ReceiveAsync();
}
catch (Exception exception)
{
log.ErrorFormat("create client failed:{0}", exception);
newClient.Disconnect();
}
}
catch
{
if (connectedSocket != null)
{
try
{
connectedSocket.Close();
}
catch
{
}
}
}
finally
{
e.Dispose();
this.AcceptAsync();
}
}
public virtual void Stop()
{
BaseServer.log.Debug("Stopping server! - Entering method");
try
{
if (this._linstener != null)
{
Socket linstener = this._linstener;
this._linstener = null;
linstener.Close();
BaseServer.log.Debug("Server is no longer listening for incoming connections!");
}
}
catch (Exception exception)
{
BaseServer.log.Error("Stop", exception);
}
if (this._clients != null)
{
object syncRoot;
Monitor.Enter(syncRoot = this._clients.SyncRoot);
try
{
BaseClient[] array = new BaseClient[this._clients.Keys.Count];
this._clients.Keys.CopyTo(array, 0);
BaseClient[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
BaseClient baseClient = array2[i];
baseClient.Disconnect();
}
BaseServer.log.Debug("Stopping server! - Cleaning up client list!");
}
catch (Exception exception2)
{
BaseServer.log.Error("Stop", exception2);
}
finally
{
Monitor.Exit(syncRoot);
}
}
BaseServer.log.Debug("Stopping server! - End of method!");
}