protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, _options.ChatPort));
listener.Start();
_logger.LogInformation("Listening for chat on {LocalEndpoint}", listener.LocalEndpoint);
while (!stoppingToken.IsCancellationRequested)
{
try
{
var client = await listener.AcceptAsync(stoppingToken);
_logger.LogInformation("Accepting chat client {RemoteEndpoint} on {LocalEndpoint}", client.Client.RemoteEndPoint, client.Client.LocalEndPoint);
_ = Task.Run(() => AcceptAsync(client, stoppingToken));
}
catch (OperationCanceledException) when(stoppingToken.IsCancellationRequested)
{
}
}
_logger.LogInformation("Stopping chat server");
}
public static async Task Server()
{
try {
using (var server = new TcpListener()) {
server.Bind(Default.IPEndPoint);
server.Listen();
using (var client = await server.AcceptAsync()) {
client.Write("Hello World!");
var str = await client.ReadStringAsync();
Console.WriteLine("From Client: {0}", str);
}
}
} catch (Exception e) {
Console.WriteLine("Server Exception:");
Console.WriteLine(e);
}
}
public static async Task Server()
{
try {
var server = new TcpListener();
server.Bind(ep);
server.Listen();
var client = await server.AcceptAsync();
client.Write(Encoding.ASCII, "Hello World!");
var str = await client.ReadStringAsync();
Console.WriteLine("From Client: {0}", str);
client.Shutdown();
server.Close();
} catch (Exception e) {
Console.WriteLine("Server Exception:");
Console.WriteLine(e);
}
}
/// <summary>
/// Called when a new client has been accepted.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TcpAcceptCompleted(object sender, SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
e.Completed -= TcpAcceptCompleted;
ObjectCache.ReturnSocketAsyncEventArgs(e);
return;
}
try
{
HandleTcpConnection(e.AcceptSocket);
}
catch (Exception ex)
{
Logger.Warning("Failed to complete connection accept as an exception occurred. Listener will continue accepting new connections.", ex);
}
// Start new accept operation
e.AcceptSocket = null;
bool completingAsync;
try
{
completingAsync = TcpListener.AcceptAsync(e);
}
catch (Exception ex)
{
Logger.Fatal("Failed to accept connections on TCP socket. The listener cannot continue.", ex);
return;
}
if (!completingAsync)
{
TcpAcceptCompleted(this, e);
}
}
/// <summary>
/// Begins accepting new connections.
/// </summary>
public override void StartListening()
{
BindSockets();
Logger.Trace("Starting bichannel listener.");
//Sort TCP
SocketAsyncEventArgs tcpArgs = ObjectCache.GetSocketAsyncEventArgs();
tcpArgs.BufferList = null;
tcpArgs.SetBuffer(null, 0, 0);
tcpArgs.Completed += TcpAcceptCompleted;
bool completingAsync = TcpListener.AcceptAsync(tcpArgs);
if (!completingAsync)
{
TcpAcceptCompleted(this, tcpArgs);
}
//Sort UDP
SocketAsyncEventArgs udpArgs = ObjectCache.GetSocketAsyncEventArgs();
udpArgs.Completed += UdpMessageReceived;
udpArgs.RemoteEndPoint = new IPEndPoint(Address, 0);
udpArgs.BufferList = null;
udpArgs.SetBuffer(new byte[ushort.MaxValue], 0, ushort.MaxValue);
completingAsync = UdpListener.ReceiveFromAsync(udpArgs);
if (!completingAsync)
{
UdpMessageReceived(this, udpArgs);
}
Logger.Info($"Server mounted, listening on port {Port}{(UdpPort != Port ? "|" + UdpPort : "")}.");
}
