Синхронный клиент-сервер, зависают окна

namespace ClientCocket
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
 
            try
            {
 
                // Буфер для входящих данных
                byte[] bytes = new byte[1024];
 
                // Соединяемся с удаленным устройством
                int intport = Convert.ToInt16(tcpport.Text);
 
                IPEndPoint hostEndPoint;
                IPAddress hostAddress = null;
                Socket s = null;
 
                IPAddress[] IPaddresses = (Dns.GetHostEntry(ip.Text)).AddressList;
                for (int index = 0; index < IPaddresses.Length; index++)
                {
                    hostAddress = IPaddresses[index];
                    if (hostAddress.AddressFamily == AddressFamily.InterNetwork)
                    {
                        hostEndPoint = new IPEndPoint(hostAddress, intport);
 
 
 
                        // Creates the Socket to send data over a TCP connection.
                        s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
                        // Connect to the host using its IPEndPoint.
                        s.Connect(hostEndPoint);
 
                        if (!s.Connected)
                        {
                            continue;
                        }
 
                        toolStripStatusLabel1.Text = @"Сокет соединяется с " + s.RemoteEndPoint.ToString();
 
                        byte[] msg = Encoding.UTF8.GetBytes(mess.Text);
 
                        // Отправляем данные через сокет
                        int bytesSent = s.Send(msg);
 
                        // Получаем ответ от сервера
                        int bytesRec = s.Receive(bytes);
 
                        textBox1.Text = textBox1.Text + @"Ответ от сервера: " +
                                        Encoding.UTF8.GetString(bytes, 0, bytesRec) + " ";
                    }
 
 
                }
 
 
                // Освобождаем сокет
                s.Shutdown(SocketShutdown.Both);
                s.Close();
            }
            catch (Exception ex)
            {
                textBox1.Text = textBox1.Text = @"Ошибка " + ex.ToString();
            }
            finally
            {
            }
 
 
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            ip.Text = @"10.133.7.6";
            tcpport.Text = @"11000";
            mess.Text = @"Простое сообщение" +"\n\n";
            toolStripStatusLabel1.Text = @"готова к работе";
            
        }

namespace TestSocket
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
 
        }
 
        private IPAddress GetLocalIP()
        {
            IPHostEntry host;
            IPAddress res = null;
            host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress ip in host.AddressList)
            {
                if (ip.AddressFamily == AddressFamily.InterNetwork)
                    return ip;
            }
            return res;
        }
 
 
        private void button1_Click(object sender, EventArgs e)
        {
            // Устанавливаем для сокета локальную конечную точку
 
            IPAddress ips = GetLocalIP();
            //IPHostEntry ipHost = Dns.GetHostEntry(ips);
            //IPAddress ipAddr = ipHost.AddressList[0];
            int port = Convert.ToInt16(textBox1.Text);
            IPEndPoint ipEndPoint = new IPEndPoint(ips, port);
 
            // Создаем сокет Tcp/Ip
            Socket sListener = new Socket(ips.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 
            // Назначаем сокет локальной конечной точке и слушаем входящие сокеты
            try
            {
                sListener.Bind(ipEndPoint);
                sListener.Listen(10);
 
                // Начинаем слушать соединения
                while (true)
                {
                    toolStripStatusLabel1.Text = "Ожидаем соединение на " + ipEndPoint.ToString();
                    Update();
                    Application.DoEvents();
                    
 
                    // Программа приостанавливается, ожидая входящее соединение
                    Socket handler = sListener.Accept();
                    string data = null;
 
                    // Мы дождались клиента, пытающегося с нами соединиться
 
                    byte[] bytes = new byte[1024];
                    int bytesRec = handler.Receive(bytes);
 
                    data += Encoding.UTF8.GetString(bytes, 0, bytesRec);
 
                    // Показываем данные в редакторе
                    Console.Write("Полученный текст: " + data + "\n\n");
                    textBox2.Text = textBox2.Text + data;
                    Update();
 
                    // Отправляем ответ клиенту
                    string reply = "От вас получен запрос: " + data;
                    byte[] msg = Encoding.UTF8.GetBytes(reply);
                    handler.Send(msg);
 
                    if (data.IndexOf("Конец") > -1)
                    {
                        break;
                    }
 
                    handler.Shutdown(SocketShutdown.Both);
                    handler.Close();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                Console.ReadLine();
            }
 
 
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            textBox1.Text = "11000";
            toolStripStatusLabel1.Text = "Готова к работе. Для прослушивания порта нажмите на кнопку";
            Update();
        }
 
    }
}

 Socket handler = sListener.Accept();

void waitAccept()
        {
            try
            {
                listener.BeginAccept(new AsyncCallback(acceptCallBack), listener); // поставили сервер на прослушку
            }
            catch (Exception ex)
            {
                outLog(ex.ToString() + "\r\nListen is closed");
            }
        }
 
void acceptCallBack(IAsyncResult ar) // метод вызывается, когда слушающий сокет получает новое подключение
        {
            try
            {
                Socket s = (Socket)ar.AsyncState; // получаем слушающий сокет
                Socket newSocket = s.EndAccept(ar); // Завершаем ожидание подключения и получаем подключающийся сокет                      
                startReceive(); // устанавливаем новый сокет на приём данных
                waitAccept(); // снова ставим слушающий сокет на ожидание новых подключений
            }
            catch (SocketException ex)
            {
                if (ex.SocketErrorCode != SocketError.ConnectionReset)
                    outLog(ex.ToString() + "ErrCode: " + ex.SocketErrorCode.ToString());  
                waitAccept();
            }
            catch (Exception ex)
            {
                outLog(ex.ToString());
                waitAccept();
            }
        }        
 
        public void startReceive() // метод устанавливающий сокет в режим получения новых данных
        {
            try
            {
                _sock.BeginReceive(incomData, 0, TNetServer.MAX_BUFFER_SIZE, SocketFlags.None, new AsyncCallback(receiveCallBack), _sock);
            }
            catch (Exception ex)
            {
                outLog("Receive data error on ID: " + strID + "\r\n" + ex.ToString());
                stopConnection(disconnectReason.SOCKET_ERROR);
            }
        }
 
 void receiveCallBack(IAsyncResult ar) // обработчик события получения новых данных
        {
            try
            {
                int countBytes = 0;
                Socket s = (Socket)ar.AsyncState; // получаем сокет, по которому пришли данные
                SocketError errCode = new SocketError();
                try
                {
                    countBytes = s.EndReceive(ar, out errCode);  // завершаем приём данных и получаем количество принятых байт
                    if (countBytes == 0) // если сработало событие, но принятых данных нет - значит клиент отключился. Удаляем его
                    {
                        stopConnection(disconnectReason.SOCKET_DISCONNECT);
                        return;
                    }
                    bytesIn += countBytes;
                }
                catch (Exception) // если сокет недоступен удаляем клиента
                {
                    stopConnection(disconnectReason.SOCKET_ERROR);
                    return;
                }
                _buffer = new byte[countBytes]; // создаём новый буфер входных данных. Размер соответствует количеству полученных данных
                Array.Copy(incomData, _buffer, countBytes); // заполняем буфер данными
 
               /* как-то обрабатываем данные, делаем нужные вещи и т.д. */
 
               startReceive(); // снова устанавливаем в режим ожидания данных
            }
            catch(Exception ex)
            {
                outLog("Error in receive incoming message\r\n" + ex.ToString());
                startReceive();
            }
        }
 
        public void sendData(byte[] data) // если нужно отправить данные
        {
            try
            {
                _sock.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(sendCallBack), _sock);
                outLog("Sending to " + strID + "\r\n" + BitConverter.ToString(data));
            }
            catch (Exception ex)
            {
                outLog("Send data error. ID: " + strID + "\r\n" + ex.ToString());
                stopConnection(disconnectReason.SOCKET_ERROR);
            }
        }
 
        void sendCallBack(IAsyncResult ar)  // метод вызываемый по окончании отправки данных
        {
            Socket s = (Socket)ar.AsyncState;   // получаем сокет в который отправили данные
            try
            {   
                int sendingBytes = s.EndSend(ar);  // завершаем передачу и получаем количество отправленных байт
                startReceive(); // ставим сокет на прослушивание
            }
            catch (Exception ex)    // если что-то пошло не так
            {
                outLog("End send error\r\n" + ex.ToString());  // пишем в лог
                stopConnection(disconnectReason.SOCKET_ERROR);   // отключаем клиента
            }
        }