Question

I have two methods on my Sender class:

public void SendMessage(OutgoingMessage msg)
{
    try
    {
        stream.BeginWrite(msg.TcpData, 0, 16, messageSentCallback, msg);
    }
    catch
    {
        // ...
    }
}

private void messageSentCallback(IAsyncResult result)
{
    stream.EndWrite(result);

    if (result.IsCompleted)
        onDataSent(result.AsyncState as OutgoingMessage);
}

Other parts of the program can call (if they have an access to the Sender) the SendMessage() method. Since the program works in multi-threading environment, multiple threads have access to the Sender object.

I have 2 questions:

Q1) Would making two concurrent calls to the SendMessage method be able to mess up the TCP communication (by filling the TCP outgoing buffer with mixed data)?

Q2) Would enclosing the stream.BeginWrite() call into the lock { } solve this problem?

As far as I understand, the call to BeginWrite simply stores the data into the TCP outgoing buffer. Is that right?

Answer 1

Yes, a lock is required to avoid problems. However, I would switch to a different approach, both to solve concurrency problems as well as to make the thread interaction more easy to reason about.

You could have a shared queue where several threads put requests that need to be written to the stream. A single thread then reads requests from the queue and makes write operations. Now it’s much easier to understand what is going on and you don’t have to worry about synchronizing the writes. You could use one of the concurrent collections like ConcurrentQueue.