public QueuedDeliveryCore(IMessageDeliveryQueue deliveryQueue, IMessageDeliveryQueue failureQueue)
        {
            _transactional = deliveryQueue.IsTransactional && failureQueue.IsTransactional;

            if (!_transactional)
            {
                throw new InvalidOperationException("Only transactional queues are allowed");
            }

            _messageDeliveryQueue = deliveryQueue;
            _failureQueue         = failureQueue;
        }
        void deliveryWork(Semaphore deliverySemaphore, IMessageDeliveryQueue queue)
        {
            if (deliverySemaphore.WaitOne(TimeSpan.FromSeconds(1), true))
            {
                bool release = true;
                try
                {
                    CommittableTransaction ct = new CommittableTransaction();

                    Transaction.Current = ct;
                    MessageDelivery md = queue.Dequeue(TimeSpan.FromSeconds(DEQUEUE_TIMEOUT_SECONDS));

                    if (md != null)
                    {
                        DeliveryWork work = new DeliveryWork(ct, md, deliverySemaphore);

                        release = false;
                        ThreadPool.QueueUserWorkItem((deliverWork) =>
                        {
                            try
                            {
                                DoSafely(() => DeliverOne((DeliveryWork)deliverWork));
                            }
                            finally
                            {
                                work.DeliverySemaphore.Release();
                            }
                        }, work);
                    }
                    else
                    {
                        ct.Dispose();
                    }
                }
                finally
                {
                    if (release)
                    {
                        deliverySemaphore.Release();
                    }
                    Transaction.Current = null;
                }
            }
        }