Принятие сообщений от сервера в бесконечном цикле (Клиент-Сервер Чат)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Environment;
 
namespace Client
{
    class Program
    {
 
        private static Socket socket;
 
        private static SocketAsyncEventArgs SockAsyncEventArgs; // объект для асинхронной операции на сокете
 
        private static byte[] buff; // буфер обмена
 
        /// <summary>
        /// инициализируем клиента
        /// </summary>
        
        /// <summary>
        /// обработка последней асинхронной операции
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void SockAsyncArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Connect:
                    ProcessConnect(e);
                    break;
                case SocketAsyncOperation.Receive:
                    ProcessReceive(e);
                    break;
                case SocketAsyncOperation.Send:
                    ProcessSend(e);
                    break;
            }
        }
        /// <summary>
        /// Подключаемся к серверу
        /// </summary>
        /// <param name="address">адрес подлючения</param>
        /// <param name="port">порт для подключения</param>
        public static void Start(string address, int port)
        {
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            buff = new byte[1024];
            SockAsyncEventArgs = new SocketAsyncEventArgs();
            // подписываемся на завершение асинхронного соединения
            SockAsyncEventArgs.Completed += SockAsyncArgs_Completed;
 
            SockAsyncEventArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(address), port);
            ConnectAsync(SockAsyncEventArgs);
        }
        private static void ConnectAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = socket.ConnectAsync(e);
            if (!willRaiseEvent)
                ProcessConnect(e);
        }
        /// <summary>
        /// если нет ошибок, задаем буфер
        /// </summary>
        /// <param name="e"></param>
        private static void ProcessConnect(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                Console.WriteLine("Установлено соединиение с {0}...", e.RemoteEndPoint.ToString());
                SockAsyncEventArgs.SetBuffer(buff, 0, buff.Length);
            }
            else
            {
                Console.WriteLine("Потеряно соединение с {0}", e.RemoteEndPoint.ToString());
            }
        }
        /// <summary>
        /// отправка сообщений
        /// </summary>
        /// <param name="data"></param>
        public static void SendAsync(string msg)
        {
            if (socket.Connected && msg.Length > 0)
            {
                byte[] buff = Encoding.UTF8.GetBytes(msg);
                SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                e.SetBuffer(buff, 0, buff.Length);
                e.Completed += SockAsyncArgs_Completed;
                SendAsync(e);
            }
        }
        private static void SendAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = socket.SendAsync(e);
            //if (!willRaiseEvent)
            //    ProcessSend(e);
        }
        /// <summary>
        /// Прием сообщений
        /// </summary>
        /// <param name="e"></param>
        private static void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                ReceiveAsync(SockAsyncEventArgs);
            }
            else
            {
                Console.WriteLine("Не отправлено");
            }
        }
        private static void ReceiveAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = socket.ReceiveAsync(e);
            if (!willRaiseEvent)
                ProcessReceive(e);
        }
        /// <summary>
        /// выводим на экран
        /// </summary>
        /// <param name="e"></param>
        private static void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                string str = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred);
                Console.WriteLine(str);
            }
            else
            {
                Console.WriteLine("Dont recieve");
            }
        }
 
        static void Main(string[] args)
        {
            Console.Title = "Клиент - чат (ver. 1)";
            Console.WriteLine("Создаем соединение с сервером");
 
            Client clnt = new Client();
            Console.ReadKey();
            Start("127.0.0.1", 1991);
            while (true)
            {
                string msg = Console.ReadLine();
                SendAsync(msg);
            }
 
 
        }
    }
}

            while (true)
            {
                string msg = Console.ReadLine();
                SendAsync(msg);
            }

private static void AcceptCompleted()
        {
            byte[] data = new byte[1024];
            int recv = socket.Receive(data, data.Length, SocketFlags.None);
 
            if (recv != 0)
            {
                string message = Encoding.UTF8.GetString(data, 0, recv);
                Console.WriteLine(message);
            }
 
        }

void ReceiveData(object nm)
        {
            byte[] data = new byte[1024];
            int Clnm = (int)nm;
            int recv = 0;
            string stringData="",stData="",userNM=userlist[Clnm];
 
            while (true)
            {
                try
                {
                    Thread sendall = new Thread(delegate() { SendToAll(stringData, Clnm); });
                    sendall.IsBackground = true;
                    Thread Privat = new Thread(delegate() { PrivatMessage(stData, false); });
                    Privat.IsBackground = true;
                    recv = client[Clnm].Receive(data);
                    if (Encoding.UTF8.GetString(data, 0, recv) == "*get_all_users_tocl*")
                    {
                        Thread getlist = new Thread(delegate() { GenUserList(Clnm); });
                        getlist.IsBackground = true;
                        getlist.Start();
                        stringData = "*get_all_users_tocl*";
                    }
                    else
                    {
                        string ttt = Encoding.UTF8.GetString(data, 0, recv);
                        if (ttt.Substring((userlist[Clnm].Length + 3)).Length >= 4)
                        {
                            if (ttt.Substring((userlist[Clnm].Length + 3), 4) == "%пр%")
                            {
                                stData = Encoding.UTF8.GetString(data, 0, recv);
                                Privat.Start();
                                stringData = "*get_all_users_tocl*";
                            }
                            else
                            {
                                stringData = Encoding.UTF8.GetString(data, 0, recv);
                                sendall.Start();
                            }
                        }
                        else
                        {
                            stringData = Encoding.UTF8.GetString(data, 0, recv);
                            sendall.Start();
                        }
                    }
                }
                catch
                {
                    AddHist("\nПользователь \"" + userNM + "\" отключился.");
                    SendToAll("\nПользователь \"" + userNM + "\" отключился.", Clnm);
                    break;
                }
                if (stringData != "*get_all_users_tocl*")
                {                    
                    AddHist(stringData);
                    if (micON)
                    {
                        aud.CurrentPosition = 0.0f;
                        aud.Play();
                    }
                    MoveHist();
                }
            } try
            {
                client[Clnm].Close();
            }
            catch { }
            client[Clnm] = null;
            userlist[Clnm] = null;
            return;
        }

public Socket ClToSr;
 
void ReceiveDataToSr()
        {
            byte[] data = new byte[1024];
            int recv;
            string stringData;
            while (true)
            {
                try
                {
                    recv = ClToSr.Receive(data);
                }
                catch { break; }
                stringData = Encoding.UTF8.GetString(data, 0, recv);
                AddHist(stringData);
                if (micON)
                {
                    aud.CurrentPosition = 0.0f;
                    aud.Play();
                }
                MoveHist();
            }
            ClToSr.Close();
            AddHist("\nСоединение c сервером было разорвано.");
            CONNECTED = false;
            StatusCHange();
            return;
        }

 
            while (true)
            {
                if (Console.KeyAvailable) // если нажата клавища 
                     {
                        string msg = Console.ReadLine();
                        SendAsync(msg);
                    }
                if (socket.Available != 0) // если в сокете есть что принимать
                    ProcessSend(SockAsyncEventArgs);
            }