Read data from NetworkStream stuck BeginRead. Networking TCP

Question

I'm new member of networking. I trying write a private game server with existing game client.

I'm using MiniServer code as example to learn.

This's code sample:

namespace TR.WebRTC.Services
{
    public class MiniServer
    {
        private TcpListener mListener;

        private class Client
        {
            private readonly TcpClient tcpClient;
            private readonly byte[] buffer;

            public Client(TcpClient tcpClient)
            {
                this.tcpClient = tcpClient;
                int bufferSize = tcpClient.ReceiveBufferSize;
                buffer = new byte[bufferSize];
            }

            public TcpClient TcpClient
            {
                get { return tcpClient; }
            }

            public byte[] Buffer
            {
                get { return buffer; }
            }

            public NetworkStream NetworkStream
            {
                get { return tcpClient.GetStream(); }
            }
        }

        private class ReadWrapper
        {
            public TcpClient client;
            public Stream s;
            public byte[] buffer;
            public int offset;
            public int totalRead;

            public ReadWrapper(TcpClient c, byte[] data)
            {
                buffer = data;
                offset = 0;
                totalRead = 0;
                client = c;
                s = client.GetStream();
            }
        }

        public MiniServer()
        {
            List<TcpClient> clientsList = new List<TcpClient>();

            Debug.WriteLine("[MiniServer] Start");
            mListener = new TcpListener(new IPEndPoint(IPAddress.Any, 2356));
            mListener.Start();

            mListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
        }

        private void AcceptTcpClientCallback(IAsyncResult asyncResult)
        {
            Debug.WriteLine("[MiniServer] AcceptTcpClientCallback");
            TcpClient tcpClient;
            try
            {
                tcpClient = mListener.EndAcceptTcpClient(asyncResult);
            }
            catch (Exception ex)
            {
                OnError(mListener, ex);
                //Stop();
                return;
            }
            mListener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
            Client client = new Client(tcpClient);
            //connectedClients.Add(client);
            NetworkStream networkStream = client.NetworkStream;
            networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
        }

        private void ReadCallback(IAsyncResult asyncResult)
        {
            Debug.WriteLine("[MiniServer] ReadCallback");

            Client client = asyncResult.AsyncState as Client;
            if (client != null)
            {
                NetworkStream networkStream = client.NetworkStream;
                int read;
                try
                {
                    read = networkStream.EndRead(asyncResult);
                }
                catch (Exception ex)
                {
                    OnError(client, ex);
                    return;
                }

                if (read == 0)
                {
                    OnClientDisconnected(client.TcpClient);
                    //connectedClients.Remove(client);
                    return;
                }

                byte[] data = new byte[read];
                Buffer.BlockCopy(client.Buffer, 0, data, 0, read);
                OnDataRead(client.TcpClient, data);
                networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);

                var streamWriter = new StreamWriter(networkStream);
                streamWriter.Write("Hello there!");
            }
        }

        private void OnDataRead(TcpClient tcpClient, byte[] data)
        {
            Debug.WriteLine("[MiniServer] OnDataRead");
        }

        private void OnClientDisconnected(TcpClient tcpClient)
        {
            Debug.WriteLine("[MiniServer] OnClientDisconnected");
        }

        private event EventHandler Error;

        private void OnError(object sender, Exception ex)
        {
            Debug.WriteLine("[MiniServer] OnError");
            EventHandler handler = Error;
            if (handler != null)
            {
                ErrorEventArgs e = new ErrorEventArgs(ex);
                handler(sender, e);
            }
        }
    }
}

But when I use client to send request to server running with debug mode. The debug stuck at line: networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client); and not call to callback function.

I don't know why? And what can I do to fix this?