Question

I had a code (lets suppose a simple chat application), I used Tcp with sync. but since Async way is better at all although it is harder to setup, I decided to change the way from sync to async. but now I am facing some problems using async.

1. Buffer size: I know that we need to consider a limited size of bytes to get the bytes from peer. I read many articles but my problem not solved, I have a very simple but worthless approach to cope with this, putting a character at the end of each message; then the receiver can understand when message is fully received. but I have another problem which prevents me from performing this approach further to another problems it has for me.

Let me explain my problem by the following code:

public void Send(byte[] message, Socket connection)
{
    connection.BeginSend(message, 
                         0, 
                         message.Length, 
                         SocketFlags.None, 
                         new AsyncCallback(OnSend), 
                         connection);
}

and on OnSend method, I just use connection.EndSend(result) where result is IAsyncResult. but when I then call Send method twice like the following code, OnReceive call back will receive both of them as a one single message.

Send(Encoding.Unicode.GetBytes("Hello"));
Send(Encoding.Unicode.GetBytes("Bye"));

my OnReceiveMethod will use Console.WriteLine(message); where message is the string received from peer. and the output using sync way must be

Hello

Bye

but in async way I receive it as a one message not two, so it is printed

HelloBye

Sincerely yours,
Peyman Mortazavi

Answer 1

With the synchronous call, you are guaranteeing that the first message is completely sent before you send the second one. With the asynchronous methods, however, you are just adding the two messages to the outgoing queue, waiting to be sent. If you happen to hit it at the right time, it may send them as two separate messages, but since you add them both so fast, it’s more than likely going to send both together. If you think of TCP/IP socket communication as a single ongoing stream of data, you’ll be much better off. You need to format your messages in a way where you can determine where they begin and end. When you receive data through the socket, you should keep adding the received messages to a buffer until you’ve determined (based of the formatting of the data) that you have received a complete message. You should not be relying on each read from the socket to be a single complete message. You should expect that it may only be a partial message or even multiple messages.