Ich habe begonnen, einen TCP-Server zu bauen, der viele Clients akzeptieren und gleichzeitig von allen Clients neue Daten empfangen kann.

Bisher habe ich IOCP für TCP-Server verwendet, was ziemlich einfach und komfortabel war, aber dieses Mal möchte ich die Async / Await-Technologie verwenden. das wurde in C # 5.0 veröffentlicht.

Das Problem ist, dass ich, als ich anfing, den Server mit async / await zu schreiben, herausgefunden habe, dass in tcp der Anwendungsfall für Server mit mehreren Benutzern async / await tech ist. und die regulären Synchronisationsmethoden funktionieren genauso.

Hier ist ein einfaches Beispiel, um genauer zu sein:

class Server
{
    private TcpListener _tcpListener;
    private List<TcpClient> _clients;
    private bool IsStarted;

    public Server(int port)
    {
        _tcpListener = new TcpListener(new IPEndPoint(IPAddress.Any, port));
        _clients = new List<TcpClient>();
        IsStarted = false;
    }

    public void Start()
    {
        IsStarted = true;
        _tcpListener.Start();
        Task.Run(() => StartAcceptClientsAsync());
    }

    public void Stop()
    {
        IsStarted = false;
        _tcpListener.Stop();
    }

    private async Task StartAcceptClientsAsync()
    {
        while (IsStarted)
        {
            // ******** Note 1 ********
            var acceptedClient = await _tcpListener.AcceptTcpClientAsync();

            _clients.Add(acceptedClient);
            IPEndPoint ipEndPoint = (IPEndPoint) acceptedClient.Client.RemoteEndPoint;
            Console.WriteLine("Accepted new client! IP: {0} Port: {1}", ipEndPoint.Address, ipEndPoint.Port);

            Task.Run(() => StartReadingDataFromClient(acceptedClient));
        }
    }

    private async void StartReadingDataFromClient(TcpClient acceptedClient)
    {
        try
        {
            IPEndPoint ipEndPoint = (IPEndPoint) acceptedClient.Client.RemoteEndPoint;
            while (true)
            {
                MemoryStream bufferStream = new MemoryStream();
                // ******** Note 2 ********
                byte[] buffer = new byte[1024];
                int packetSize = await acceptedClient.GetStream().ReadAsync(buffer, 0, buffer.Length);

                if (packetSize == 0)
                {
                    break;
                }

                Console.WriteLine("Accepted new message from: IP: {0} Port: {1}\nMessage: {2}",
                    ipEndPoint.Address, ipEndPoint.Port, Encoding.Default.GetString(buffer));
            }
        }
        catch (Exception)
        { 
        }
        finally
        {
            acceptedClient.Close();
            _clients.Remove(acceptedClient);
        }
    }
}

Wenn Sie nun die Zeilen unter 'Note 1' und 'Note 2' sehen, können Sie diese leicht ändern in:

Anmerkung 1 von

var acceptedClient = await _tcpListener.AcceptTcpClientAsync();

zu

var acceptedClient = _tcpListener.AcceptTcpClient();

Und Note 2 von

int packetSize = await acceptedClient.GetStream().ReadAsync(buffer, 0, 1024);

zu

int packetSize = acceptedClient.GetStream().Read(buffer, 0, 1024);

Und der Server wird genauso funktionieren.

Warum sollten Sie async / await im tcp-Listener für mehrere Benutzer verwenden, wenn dies mit normalen Synchronisationsmethoden vergleichbar ist?

Sollte ich in diesem Fall weiterhin IOCP verwenden? weil es für mich ziemlich einfach und bequem ist, aber ich befürchte, dass es in neueren .NET-Versionen veraltet oder gar nicht mehr verfügbar sein wird.