TcpClient connected but server not receiving message

Question

Server :

public class TcpServer
{
    private TcpListener tcpListener;
    private static ManualResetEvent allDone = new ManualResetEvent(false);

    public TcpServer(string url, int port)
    {
        tcpListener = new TcpListener(IPAddress.Parse(url), port);
        pingMapper = new LightPingMapper();
    }


    public void Run()
    {
        tcpListener.Start();

        Console.WriteLine("Server running");
        while (true)
        {
            allDone.Reset();
            tcpListener.BeginAcceptSocket(AcceptCallback, tcpListener);
            Console.WriteLine("Accepting socket");
            allDone.WaitOne();
        }

        Console.ReadLine();
    }

    private void AcceptCallback(IAsyncResult result)
    {
        try
        {
            allDone.Set();

            var listener = (TcpListener) result.AsyncState;
            var handler = listener.EndAcceptSocket(result);

            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0, state.buffer.Length, 0, ReadCallback, state);
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error accepting callback. {e.Message}");
        }
    }

    private void ReadCallback(IAsyncResult asyncResult)
    {
        try
        {
            string content = string.Empty;
            Console.WriteLine("Read data from socket");

            StateObject state = (StateObject) asyncResult.AsyncState;
            Socket handler = state.workSocket;

            int bytesRead = handler.EndReceive(asyncResult);
            if (bytesRead > 0)
            {
                state.sb.Append(Encoding.UTF8.GetString(state.buffer));
                content = state.sb.ToString();
                Console.WriteLine(content + " "  + DateTime.Now);                    
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error reading socket. {e.Message}");
        }
    }
}

class StateObject
{
    // Client  socket.  
    public Socket workSocket = null;
    // Size of receive buffer.  
    public const int BufferSize = 256;
    // Receive buffer.  
    public byte[] buffer = new byte[BufferSize];
    // Received data string.  
    public StringBuilder sb = new StringBuilder();
}

Client:

public class TCPClientWrapper
{
    private TcpClient tcpClient;
    private readonly string address;
    private readonly int port;

    public TCPClientWrapper(string address, int port)
    {
        InitTcpClient();
        this.address = address;
        this.port = port;
    }

    public void SendMessage()
    {
        for(int i=0; i < 10; i++)
        {
            if (!SocketConnected())
            {
                TryConnect();
            }               

            byte[] buffer = Encoding.UTF8.GetBytes("Hello");
            tcpClient.Client.Send(buffer);
            Thread.Sleep(60000);
        }
    }

    private void TryConnect()
    {
        bool isConnected = false;
        while (true)
        {
            try
            {
                InitTcpClient();

                tcpClient.Connect(IPAddress.Parse(address), port);
                if (SocketConnected())
                {
                    Console.WriteLine("TcpClient, Connected");
                    isConnected = true;
                    break;
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("TcpClient, connection failed. Try to reconnect after 30 seconds, {0}", e.Message);
            }
            finally
            {
                if (!isConnected)
                {
                    tcpClient.Close();
                    Thread.Sleep(30000);
                }
            }
        }
    }

    private void InitTcpClient()
    {            
        tcpClient = new TcpClient();
        tcpClient.SendTimeout = 15;
    }

    private bool SocketConnected()
    {
        var s = tcpClient.Client;

        if (!s.Connected)
            return false;

        bool part1 = s.Poll(1000, SelectMode.SelectRead);
        bool part2 = s.Available == 0;
        return !(part1 && part2);
    }

}

The problem is that server read only first message , each next message is not received by server . The tcpClient is connected , but server doesn't receive any message . Could anyone suggest what is wrong with my code ?

Answer 1

In ReadCallback, you don't start the next read - so yes, your code only reads once.

Adding

handler.BeginReceive(state.buffer, 0, state.buffer.Length, 0, ReadCallback, state);

to the bottom of ReadCallback (when bytesRead > 0) should work. However! You aren't implementing proper framing, so you should be very cautious of that. A basic framing implementation for a text-based protocol (like this) would be to use some kind of line-end sentinel, and buffer data until you see a line-end, then process the line.

On TCP, you are only guaranteed to get the right bytes in the right order (or a failed socket eventually) - you are not guaranteed to get them in the same composition in terms of calls to Send exactly matching calls to Receive in terms of the numbers of bytes in each.