Simple async await tcp server design

Question

I'm designing an asynchronous TCP server using async-await approach making use of event-driven .NET environment with the following features:

1. Request and response functionality.
2. Server side initiated events.

Does this server design is correct in terms of async-await approach?
Code below covers only basic functionality to judge whether I'm missing something or not.
The server uses COM Type library, which is where PRMasterAutomation class comes from.

public class AsyncServer {
    private const int BufferSize = 4096;
    private static bool ServerRunning = true;       
    private List<TcpClient> clients = new List<TcpClient>();
    private PRMasterAutomation automation;

    public AsyncServer()
    {            
        InitializeComponent();
        automation = new PRMasterAutomation();
        automation.OnMonitoringEvent += automation_OnMonitoringEvent;

        if (!automation.Login("ADMIN", "")) 
            return;            

        if (automation.GetPRMasterState() == PRMasterStateEnum.StateIdle)
            automation.StartMonitoring();

        var tcpServer = new TcpListener(IPAddress.Any, 9001);
        tcpServer.Start();
        ListenForClients(tcpServer);                       
    }

    private async void ListenForClients(TcpListener tcpServer)
    {
        while (ServerRunning)
        {
            TcpClient tcpClient = await tcpServer.AcceptTcpClientAsync();
            clients.Add(tcpClient);
            ProcessClient(tcpClient);
        }
    }

    private async void ProcessClient(TcpClient tcpClient)
    {
        var stream = tcpClient.GetStream();
        var buffer = new byte[BufferSize];
        int amountRead;
        string xml;
        while (ServerRunning)            
        {
            if ((amountRead = await stream.ReadAsync(buffer, 0, BufferSize)) > 0)
            {
                var message = Encoding.ASCII.GetString(buffer, 0, amountRead);
                xml = "";
                if (message.Equals("get_users"))
                {
                    xml = automation.GetUsersXml();                                               
                }
                else if (message.Equals("get_events"))
                {
                    xml = automation.GetEventsHistoryXml("");
                }

                if (xml.Length > 0)
                {
                    xml += "\r\n"; 
                    await stream.WriteAsync(Encoding.ASCII.GetBytes(xml), 0, xml.Length);
                }
            }
        }
    }

    async void automation_OnMonitoringEvent(DateTime date, DateTime time, int networkID, int readerID, int userID, int groupID, int eventCode, int zoneID, int TandAID, string strEvent, string strAccessPoint, string strUserSource, string strGroup, string strNetwork, string strZone, string strTandAMode)
    {
        foreach (var c in clients)
        {
            if (c != null && c.Connected)
            {
                var stream = c.GetStream();
                StringBuilder sb = new StringBuilder();
                sb.Append(date.ToString() + ";" + time.ToString() + ";" + networkID.ToString() + ";" + userID.ToString() + "\r\n");
                await stream.WriteAsync(Encoding.ASCII.GetBytes(sb.ToString()), 0, sb.Length);
            }   
        }            
    }
}

Answer 1

Does this server design is correct in terms of async-await approach?

Yes, but not in terms of sockets. ReadAsync will return any number of bytes between 1 and infinite, it will not return messages.

Stream.ReadAsync(): The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached.

You have to create a buffer and keep reading and adding to that buffer until you know you have received a whole message. This means checking for \r\n in your case. If you encounter such a delimiter, you can extract the message from the buffer and start receiving a new message.