Question

I’m using a BlockingCollection to implement a producer/consumer pattern. I have an asynchronous loop that fills the collection with data to be processed which can then at a much later time be accessed by the client. The packets arrive sparsely and I would like the polling to be done without using a blocking call to take.

In essence, I’m looking for something like a BeginTake and EndTake that does not exist in the blocking collection so that I can make use of the internal thread pool in a callback. It does not have to be a BlockingCollection by any means. Anything that does what I need would be great.

This is what I’ve got now. _bufferedPackets is a BlockingCollection<byte[]>:

public byte[] Read(int timeout)
{
    byte[] result;
    if (_bufferedPackets.IsCompleted)
    {
        throw new Exception("Out of packets");
    }
    _bufferedPackets.TryTake(out result, timeout);      
    return result;
}

I’d like this to be something like this, in pseudocode:

public void Read(int timeout)
{
    _bufferedPackets.BeginTake(result =>
        {
            var bytes = _bufferedPackets.EndTake(result);
            // Process the bytes, or the resuting timeout
        }, timeout, _bufferedPackets);
}

What are my options for this? I do not want to place any thread in a waiting state, since there is lots of other IO stuff for it to process, and I would run out of threads pretty quickly.

Update: I’ve rewritten the code in question to use the async process differently, essentially swapping callbacks based on if there is a waiting request within the timeout limit. This works fine, but still it would be awesome if there was a way to do this without resorting to timers and swapping lambdas around which potentially causes race conditions and is hard to write (and understand). I have solved this also with an own implementation of an async queue, but it would still be awesome if there was a more standard and well tested option.

Answer 1

So there doesn’t look to be a built in option for this, I went out and tried to do my best to make what I wanted as an experiment. Turns out there is a lot of cruft to do in order to make this work roughly as other users of the old async pattern.

public class AsyncQueue<T>
{
    private readonly ConcurrentQueue<T> queue;
    private readonly ConcurrentQueue<DequeueAsyncResult> dequeueQueue; 

    private class DequeueAsyncResult : IAsyncResult
    {
        public bool IsCompleted { get; set; }
        public WaitHandle AsyncWaitHandle { get; set; }
        public object AsyncState { get; set; }
        public bool CompletedSynchronously { get; set; }
        public T Result { get; set; }

        public AsyncCallback Callback { get; set; }
    }

    public AsyncQueue()
    {
        dequeueQueue = new ConcurrentQueue<DequeueAsyncResult>();
        queue = new ConcurrentQueue<T>();
    }

    public void Enqueue(T item)
    {
        DequeueAsyncResult asyncResult;
        while  (dequeueQueue.TryDequeue(out asyncResult))
        {
            if (!asyncResult.IsCompleted)
            {
                asyncResult.IsCompleted = true;
                asyncResult.Result = item;

                ThreadPool.QueueUserWorkItem(state =>
                {
                    if (asyncResult.Callback != null)
                    {
                        asyncResult.Callback(asyncResult);
                    }
                    else
                    {
                        ((EventWaitHandle) asyncResult.AsyncWaitHandle).Set();
                    }
                });
                return;
            }
        }
        queue.Enqueue(item);
    }

    public IAsyncResult BeginDequeue(int timeout, AsyncCallback callback, object state)
    {
        T result;
        if (queue.TryDequeue(out result))
        {
            var dequeueAsyncResult = new DequeueAsyncResult
            {
                IsCompleted = true, 
                AsyncWaitHandle = new EventWaitHandle(true, EventResetMode.ManualReset), 
                AsyncState = state, 
                CompletedSynchronously = true, 
                Result = result
            };
            if (null != callback)
            {
                callback(dequeueAsyncResult);
            }
            return dequeueAsyncResult;
        }

        var pendingResult = new DequeueAsyncResult
        {
            AsyncState = state, 
            IsCompleted = false, 
            AsyncWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset), 
            CompletedSynchronously = false,
            Callback = callback
        };
        dequeueQueue.Enqueue(pendingResult);
        Timer t = null;
        t = new Timer(_ =>
        {
            if (!pendingResult.IsCompleted)
            {
                pendingResult.IsCompleted = true;
                if (null != callback)
                {
                    callback(pendingResult);
                }
                else
                {
                    ((EventWaitHandle)pendingResult.AsyncWaitHandle).Set();
                }
            }
            t.Dispose();
        }, new object(), timeout, Timeout.Infinite);

        return pendingResult;
    }

    public T EndDequeue(IAsyncResult result)
    {
        var dequeueResult = (DequeueAsyncResult) result;
        return dequeueResult.Result;
    }
}

I’m not too sure about the synchronization of the IsComplete property, and I’m not too hot on how the dequeueQueue only gets cleaned up on subsequent Enqueue calls. I’m not sure when is the correct time to signal the wait handles either but this is the best solution that I’ve got so far.

Please do not consider this production quality code by any means. I just wanted to show the general gist of how I got around to keeping all threads spinning without waiting locks. I’m sure this is full of all kinds of edge cases and bugs but it fulfills the requirements and I wanted to give something back to people who comes across the question.