public static void ReadCallbackServer(IAsyncResult ar)
        {
            String content = String.Empty;

            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            StateServerObject state   = (StateServerObject)ar.AsyncState;
            Socket            handler = state.workSocket;

            // Read data from the client socket.
            int bytesRead = handler.EndReceive(ar);

            if (bytesRead > 0)
            {
                // There  might be more data, so store the data received so far.
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                // Check for end-of-file tag. If it is not there, read
                // more data.
                content = state.sb.ToString();
                if (content.IndexOf("<EOF>") > -1)
                {
                    // All the data has been read from the
                    // client. Display it on the console.
                    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);

                    // Echo the data back to the client.
                    var forwardClient = new AsynchronousClient();
                    content +=
                        ". This message was received from the client at the middleware and spied on. It has been passed on to the server.";
                    var response = forwardClient.ConnectAndGetResponse(27005, content);
                    SendServer(handler, response);
                }
                else
                {
                    // Not all data received. Get more.
                    handler.BeginReceive(
                        state.buffer,
                        0,
                        StateServerObject.BufferSize,
                        0,
                        new AsyncCallback(ReadCallbackServer),
                        state);
                }
            }
        }
        public static void AcceptCallbackServer(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            var listener = (Socket)ar.AsyncState;
            var handler  = listener.EndAccept(ar);

            // Create the state object.
            var state = new StateServerObject {
                workSocket = handler
            };

            handler.BeginReceive(
                state.buffer,
                0,
                StateServerObject.BufferSize,
                0,
                new AsyncCallback(ReadCallbackServer),
                state);
        }