C# and TCP Client (Async) has very high CPU load & How to detect disconnected clients?

Question

the CPU load 90+ if multiple clients connect. If i start the listener and have no connection, everything is great. If i have one or more Connections i have a really high CPU load.

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace Test.Socket
{
    public class Server
    {
        List<Thread> WorkListenerThread;

        TcpListener Listener;

        public Server()
        {
            WorkListenerThread = new List<Thread>();
        }

        public void Start()
        {
            try
            {
                Listener = new TcpListener(IPAddress.Any, 12345);
                Listener.Start();
                StartTCPClientListener();
            }
            catch (Exception) { }
        }

        private void StartTCPClientListener()
        {
            Listener.BeginAcceptTcpClient(new AsyncCallback(HandleTCPClientConnection), null);
        }

        private void HandleTCPClientConnection(IAsyncResult ar)
        {
            // Problem 1: after the first connection i have a high cpu load
            try
            {
                TcpClient client = Listener.EndAcceptTcpClient(ar);
                Thread clientThread = new Thread(Communicator.CreateConnection);
                clientThread.Start(client);
                WorkListenerThread.Add(clientThread);

                StartTCPClientListener(); // Next client
            }
            catch (Exception) { }
        }

        public void Stop()
        {
            foreach (Thread th in WorkListenerThread)
                if (th.IsAlive)
                    th.Abort();

            // Problem 2: Exception because the "HandleTCPClientConnection" get a wrong IAsyncResult
            if (Listener != null)
                Listener.Stop();
        }
    }
}

And my client class.

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using JsonExSerializer;

namespace Test.Socket
{
    class Communicator
    {
        private TcpClient TcpClient = null;
        private NetworkStream Stream = null;

        private Communicator(TcpClient client)
        {
            TcpClient = client;
            Stream = TcpClient.GetStream();
            StartCommunication();
        }

        public static void CreateConnection(object c)
        {
            new Communicator(c as TcpClient);
        }

        private void StartCommunication()
        {
            string message; // The message
            int bytesRead; // Message length
            byte[] buffer = new byte[512]; // buffer

            while (true)
            {
                message = String.Empty;
                do
                {
                    bytesRead = Stream.Read(buffer, 0, buffer.Length);
                    message += Encoding.Default.GetString(buffer, 0, bytesRead);
                } while (!message.EndsWith("\r\n.\r\n"));

                Send("OK", Stream);
            }
        }

        protected void Send(string message, NetworkStream clientStream)
        {
            byte[] temp = Encoding.Default.GetBytes(message);
            clientStream.Write(temp, 0, temp.Length);
            clientStream.Flush();
        }
    }
}

I dont know whats wrong -.-

And anyone know how i candetect if a client is disconnected? That would be nice, too.

But fixing the high CPU Load would be great enough.

Answer 1

I'm guessing the main problem is here:

while (true)
{
    message = String.Empty;
    do
    {
        bytesRead = Stream.Read(buffer, 0, buffer.Length);
        message += Encoding.Default.GetString(buffer, 0, bytesRead);
    } while (!message.EndsWith("\r\n.\r\n"));

    Send("OK", Stream);
}

You should check whether this bytesRead is non-positive; if it is, that is the end of the stream and you should terminate: no more data is ever coming, but you are in a tight loop appending empty strings forever.

However! The bigger problem is the approach: thread-per-client simply doesn't scale, and is not what people mean when they mention "async IO".

I would also say that having a constructor that starts a long-running operation (so doesn't return) is a horrible thing to do.