C# TcpClient, Can following setup Deadlock (2 seperate programs communicating via TcpClient)

Question

I have 2 seperate program instances running on different computers. They are connected to each other other via a TcpClient (well 2 connections, an ingoing and outgoing, I am aware a TcpClient allows messages both ways, but for code simplicity it is easier to establish 2 connections).

Both are sending a lot of messages, and will be sending more data then there is in the buffer. Both threads run through a cycle of reading then writing.

ReceiveIncomingMessagesFromTcpClient()
ParseAndDeliverIncomingMessagesInternaly()
CollectNewOutgoingMessagesInternaly()
DeliverOutgoingMessagesViaTcpClient()

My program seems to run fine, and then stops sending messages, so I fear that the reason for this is that both are trying to Write Outgoing messages to their respective streams, both streams are full, and as nothing is there to empty the streams I have a deadlocked program.

If that is the case verify if there is room in the buffer before I start sending the message, and only send what is room for? (to avoid blocking a send, and due to this enter the deadlock?)

---

I have this function that sends the data, it can be called a lot of times in a row. The buffer size of the connection is the default 8kb.

So if this action gets repeated enough times in a row the 8kb buffer will get filled, and the stream.Write() is a blocking statement, until the other side pulls the data.

As the other side is a perfect mirror, if it has pulled a lot of data to send, both sides can be trying to send at the same time, causing the deadlock.

private void DeliverOutgoingMessagesViaTcpClient()
{
    for(int i = 0; i < message.Count;i++)
    {
        //send request
        Byte[] data = System.Text.Encoding.ASCII.GetBytes(message[i]);
        NetworkStream stream = connection.GetStream();
        stream.Write(data, 0, data.Length);
    }
}

Answer 1

Based on the feedback, it seems my issue is that I risk blocking when two communicating programs both have their sending messages blocked. So I moved the sending function to a seperate class now.

Following is the class I decided to use. It should be started up once ready for use, and can be called with a target TcpClient and a message, the call can be done either Blocking or Nonblocking (Nonblocking returns true is message is accepted)

    public class TcpSender
    {
        Mutex moveToInternal = new Mutex();
        Mutex startOnce = new Mutex();

        List<Message> internalMessages = new List<Message>();
        List<Message> externalMessages = new List<Message>();

        Thread mainLoop;

        String status = "stopped";

        //returns true if started.
        public Boolean Start()
        {
            if (startOnce.WaitOne(0))
            {
                status = "started";
                mainLoop = new Thread(new ThreadStart(InternalMainLoop));
                mainLoop.IsBackground = true;
                mainLoop.Start();
                return true;
            }
            return false;
        }

        private void InternalMainLoop()
        {

                while (status == "started")
                {
                    Boolean didSomething = false;

                    //pickup new messages and move to internal buffer
                    if (externalMessages.Count > 0)
                    {
                        didSomething = true;
                        if (moveToInternal.WaitOne())
                        {
                            internalMessages.AddRange(externalMessages);
                            externalMessages.Clear();
                            moveToInternal.ReleaseMutex();
                        }
                    }

                    //deliver messages
                    for (int i = 0; i < internalMessages.Count; i++)
                    {
                        //send request
                        Byte[] data = System.Text.Encoding.ASCII.GetBytes(internalMessages[i].GetMessage());
                        NetworkStream stream = internalMessages[i].GetClient().GetStream();
                        stream.Write(data, 0, data.Length);
                    }
                    internalMessages.Clear();

                    if (!didSomething) Thread.Sleep(1); //Nothing to receive or send, maybe tomorr... next milisec there is something to do
                }
                startOnce.ReleaseMutex();
        }

        public void Stop()
        {
            status = "stopped";
        }

        public Boolean Status()
        {
            return (status == "started");
        }

        //return true if message was accepted
        public Boolean addMessageNonBlocking(TcpClient client, String message)
        {
            Boolean gotMutex = false;
            if(gotMutex = moveToInternal.WaitOne(0));
            {
                Message tmpMessage = new Message(client, message);
                externalMessages.Add(tmpMessage);
                moveToInternal.ReleaseMutex();
            }
            return gotMutex;
        }

        public void addMessageBlocking(TcpClient client, String message)
        {
            //loop until message is delivered
            while (!addMessageNonBlocking(client, message))
            {
                Thread.Sleep(1); //could skip this, but no need for busy waiting
            }
        }

        private class Message
        {
            TcpClient client;
            String message;

            public Message(TcpClient client, String message)
            {
                this.client = client;
                this.message = message;
            }

            public TcpClient GetClient()
            {
                return client;
            }

            public String GetMessage()
            {
                return message;
            }
        }
    }

---

Test Code for verifying if TcpClient is blocking

Add this code anywhere it can be run. testClient must be a TcpClient that is connected to anywhere.

int i = 0;
String testmsg = "This is a 25 char test!!!";
Byte[] data = System.Text.Encoding.ASCII.GetBytes(testmsg);
while (true)
{
    i++;
    testClient.GetStream().Write(data, 0, data.Length);
    if (i % 10 == 0) Console.WriteLine("Cycle Count: " + i);
}