How do I make sure I receive the whole message if it doesn't fit in the buffer in TCP?

Question

I recently started to work with TCP in C#. I'm now at the point where I want the client to receive the data sent by the server.

I know that there is no guarantee for the client to receive all data at once. If the size of the data sent is bigger than the buffer's size at the client's side, then the data will be sent in parts. So my question is: how can I store all my received data in a byte array, and then convert it to the actual message when all is received?

I've set the buffer size to 1, so I can see what happens when all sent data doesn't fit in the buffer. Here are my methods in which I call stream.BeginRead() in Client.cs:

// Deliberately setting the buffer size to 1, to simulate what happens when the message doesn't fit in the buffer.
int bufferSize = 1;
byte[] receiveBuffer;

private void ConnectCallback(IAsyncResult result)
{
    client.EndConnect(result);

    Console.WriteLine("Connected to server.");

    stream = client.GetStream();

    // At this point, the client is connected, and we're expecting a message: "Welcome!"
    receiveBuffer = new byte[bufferSize];
    stream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, new AsyncCallback(ReadCallback), stream);
}

private void ReadCallback(IAsyncResult result)
{
    int bytesLength = stream.EndRead(result);

    // Should be "Welcome!". But of course it's "W", because the bufferSize is 1.
    string message = Encoding.UTF8.GetString(receiveBuffer, 0, bytesLength);

    Console.WriteLine("Received message: {0}", receivedMessage);

    // Reset the buffer and begin reading a new message, which will be "e".
    // However, I want the whole message ("Welcome!") in one byte array.
    receiveBuffer = new byte[bufferSize];
    stream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReadCallback, null);
}

This is the output when sending the message "Welcome!":

Connected to server.
Received message: W
Received message: e
Received message: l
Received message: c
Received message: o
Received message: m
Received message: e
Received message: !

Should I temporary store the data until the whole message has arrived, and then convert that to a string?

Follow up question: What if 2 messages are sent closely after each other, for example Welcome! and then What's your name? How do I distinguish the two messages then?

Answer 1

Should I temporary store the data until the whole message has arrived, and then convert that to a string?

Yes, exactly.

Follow up question: What if 2 messages are sent closely after each other, for example Welcome! and then What's your name? How do I distinguish the two messages then?

The general approach is to send the length of the message before the message itself. That way the receiving end will know when it has received a complete package.