blocking queue in Unity

Question

I want to implement a custom TCP Client in Unity that has separate threads for sending and receiving certain messages. For sending, the Client is supposed to have a blocking queue, that

• receives messages from other threads and
• the message-sending thread polls messages from the queue and sends them - but blocks when the queue is empty.

In on .net 3.5 I do not have access to BlockingCollection.

I would have expected that some implementation existed. So far I have found implementation that simply lock on a queue, which from my understanding is not sufficient.

How could I implement this?

Answer 1

This implementation shared by Stephen Toub is literally the second Google search result for "blocking queue c#" so don't underestimate the value of doing your own research. ;)

Code reproduced below in case the link ever breaks. Comments are mine:

using System.Threading;
using System.Collections.Generic;

class BlockingQueue<T> : IEnumerable<T>    
{    
    private int _count = 0;

    private Queue<T> _queue = new Queue<T>();

    public T Dequeue()    
    {    
        lock (_queue)    
        {   
            // If we have items remaining in the queue, skip over this. 
            while (_count <= 0) 
            {
                // Release the lock and block on this line until someone
                // adds something to the queue, resuming once they 
                // release the lock again.
                Monitor.Wait(_queue);
            }

            _count--;

            return _queue.Dequeue();    
        }    
    }

    public void Enqueue(T data)    
    {    
        if (data == null) throw new ArgumentNullException(“data”);

        lock (_queue)    
        {    
            _queue.Enqueue(data);

            _count++;

            // If the consumer thread is waiting for an item
            // to be added to the queue, this will move it
            // to a waiting list, to resume execution
            // once we release our lock.
            Monitor.Pulse(_queue);    
        }    
    }

    // Lets the consumer thread consume the queue with a foreach loop.
    IEnumerator<T> IEnumerable<T>.GetEnumerator()    
    {    
        while (true) yield return Dequeue();    
    }    

    IEnumerator IEnumerable.GetEnumerator()    
    {    
        return ((IEnumerable<T>)this).GetEnumerator();    
    }    
}