Асинхронный обмен данными с сервером

namespace TestSocketAsyncClient
{
    class Client
    {
        private Socket Sock;
        private SocketAsyncEventArgs SockAsyncArgs;
        private byte[] buff;
 
        public Client()
        {
            buff = new byte[1024];
            Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            SockAsyncArgs = new SocketAsyncEventArgs();
            SockAsyncArgs.Completed += SockAsyncArgs_Completed;
        }
 
        public void ConnectAsync(string Address, int Port)
        {
            SockAsyncArgs.RemoteEndPoint = new DnsEndPoint(Address, Port);
            ConnectAsync(SockAsyncArgs);
        }
        private void ConnectAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = Sock.ConnectAsync(e);
            if (!willRaiseEvent)
                ProcessConnect(e);
        }
 
        public void SendAsync(string data)
        {
            if (Sock.Connected && data.Length > 0)
            {
                byte[] buff = Encoding.UTF8.GetBytes(data);
                SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                e.SetBuffer(buff, 0, buff.Length);
                e.Completed += SockAsyncArgs_Completed;
                SendAsync(e);
            }
        }
        private void SendAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = Sock.SendAsync(e);
            if (!willRaiseEvent)
                ProcessSend(e);
        }
 
        private void ReceiveAsync(SocketAsyncEventArgs e)
        {
            bool willRaiseEvent = Sock.ReceiveAsync(e);
            if (!willRaiseEvent)
                ProcessReceive(e);
        }
 
        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;
            }
        }
 
        private void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                ReceiveAsync(SockAsyncArgs);
            }
            else
            {
                Console.WriteLine("Dont send");
            }
        }
 
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                string str = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred);
                Console.WriteLine("Receive: {0}", str);
            }
            else
            {
                Console.WriteLine("Dont recieve");
            }
        }
 
        private void ProcessConnect(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success)
            {
                Console.WriteLine("Connected to {0}...", e.RemoteEndPoint.ToString());
                SockAsyncArgs.SetBuffer(buff, 0, buff.Length);
            }
            else
            {
                Console.WriteLine("Dont connect to {0}", e.RemoteEndPoint.ToString());
            }
        }
    }
}
 
   .....
 
static void Main(string[] args)
        {
            Client Cl = new Client();
            Cl.ConnectAsync("127.0.0.1", 5321);
 
            while (true)
            {
                string data = Console.ReadLine();
                Cl.SendAsync(data);
            }
        }

        private void ReceiveCallback(IAsyncResult result)
        {
            ConnectionInfo connection =
                (ConnectionInfo)result.AsyncState;
            try
            {
                int bytesRead = connection.Socket.EndReceive(result);
 
                if (0 != bytesRead)
                {
                    lock (_connections)
                    {
                        foreach (ConnectionInfo conn in _connections)
                        {
                            // тут получаем сообщение от клиента и отправляем ответ ему ответ
                            if (connection == conn)
                            {
                                string str = Encoding.Unicode.GetString(connection.Buffer, 0, bytesRead);
 
                                Console.WriteLine(str);
 
                                conn.Socket.Send(SendMessage(Program.dbCache.Search(str)),
                                    bytesRead, SocketFlags.None);
                            }
                        }
                    }
 
                    connection.Socket.BeginReceive(connection.Buffer, 0,
                        connection.Buffer.Length, SocketFlags.None,
                        new AsyncCallback(ReceiveCallback),
                        connection);
                }
                else CloseConnection(connection);
            }
            catch (SocketException exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Socket exception: " +
                    exc.SocketErrorCode);
            }
            catch (Exception exc)
            {
                CloseConnection(connection);
                Console.WriteLine("Exception: " + exc);
            }
        }