using System;
using System.Collections.Generic;
using System.Text;

namespace tld.domain.Tools
{
    public class TriggerQueue<T> : Queue<T>
    {
        /// <summary>
        /// ItemEnqueued
        /// </summary>
        /// <param name="sender">sender</param>
        public delegate void ItemEnqueuedHandler(object sender);

        /// <summary>
        /// ItemDequeued
        /// </summary>
        /// <param name="sender">sender</param>
        public delegate void ItemDequeuedHandler(object sender);

        /// <summary>
        /// Triggered when the queue count reached EnqueueTriggerLimit
        /// </summary>
        public event ItemEnqueuedHandler ItemEnqueued;

        /// <summary>
        /// Triggered when an item gets dequeued
        /// </summary>
        public event ItemDequeuedHandler ItemDequeued;


        private int enqueueTriggerLimit = 1;

        /// <summary>
        /// Queue lenght limit used to determine when the ItemEnqueue event fires
        /// </summary>
        public int EnqueueTriggerLimit { get; set; }

        /// <summary>
        /// Default constructor
        /// </summary>
        public TriggerQueue() : base() { }

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="enqueTrigger">Limit at which the event ItemEnqueued fires</param>
        public TriggerQueue(int enqueTrigger) : base() { this.enqueueTriggerLimit = enqueTrigger; }

        public new void Enqueue(T item)
        {
            // Enqueue the object into the base queue
            base.Enqueue(item);

            // Trigger the event if we reached the limit
            if (Count == EnqueueTriggerLimit)
                ItemEnqueued(this);
        }

        //public new T Dequeue()
        //{
        //    ItemDequeued(this);
        //    return base.Dequeue();
        //}
    }
}

// Trigger the event if we reached the limit
if (Count == EnqueueTriggerLimit)
   ItemEnqueued(this);

EventHandler tempHandler = this.EventHandlerName;
if (null != tempHandler)
{
     tempHandler(this, e);
}

using System;
using System.Collections.Generic;
using System.Text;

namespace tld.domain.Tools
{
    public class GenericTriggerQueue<T>
    {
        /// <summary>
        /// Queue holding our objects of type T
        /// </summary>
        private Queue<T> queue = new Queue<T>();

        /// <summary>
        /// 
        /// </summary>
        public int QueueLimit { get; set; }

        public delegate void OnQueueLimitReachedEventHandler(object sender, EventArgs e);
        public event OnQueueLimitReachedEventHandler QueueLimitReached;

        public GenericTriggerQueue(int queueLimit)
        {
            QueueLimit = queueLimit;
        }

        public int Count { get { return queue.Count; } }

        /// <summary>
        /// Enqueues an item
        /// </summary>
        /// <param name="item">Item to be enqueued</param>
        public void Enqueue(T item)
        {
            // Lock the queue for purposes of correctness
            lock(queue)
            {
                // Enque the item
                queue.Enqueue(item);

                // Check for the limit
                if (queue.Count == QueueLimit)
                    // And fire the event
                    this.QueueLimitReached(this, null);
            }
        }

        /// <summary>
        /// Dequeues an item from the queue
        /// </summary>
        /// <returns>Item of type T</returns>
        public T Dequeue()
        {
            return queue.Dequeue();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace QueueImplementation
{
    class Program
    {
        static void Main(string[] args)
        {
            ObservableQueue<int> queue = new ObservableQueue<int>(10);
            queue.LimitReached += delegate(object sender, EventArgs e)
            {
                Console.WriteLine("Queue limit reached.");
            };

            queue.ItemEnqueued += delegate(object sender, ItemEventArgs<int> e)
            {
                Console.WriteLine("Item {0} enqueued", e.Item);
            };

            queue.ItemDequeued += delegate(object sender, ItemEventArgs<int> e)
            {
                Console.WriteLine("Item {0} dqueued", e.Item);
            };

            Random random = new Random();
            for (int i = 0; i < 15; i++)
            {
                queue.Enqueue(random.Next(100));
            }

            Console.ReadLine();
        }
    }

    public class ItemEventArgs<T>
        : EventArgs
    {
        public ItemEventArgs(T item)
        {
            this.Item = item;
        }

        public T Item { get; private set; }
    }

    public class ObservableQueue<T>
    {
        private Queue<T> queue = new Queue<T>();

        public ObservableQueue(int limit)
        {
            if (0 >= limit)
            {
                throw new ArgumentOutOfRangeException("limit");
            }

            this.Limit = limit;
        }

        public event EventHandler LimitReached;
        public event EventHandler<ItemEventArgs<T>> ItemEnqueued;
        public event EventHandler<ItemEventArgs<T>> ItemDequeued;

        public int Limit { get; private set; }
        public int Count
        {
            get
            {
                return this.queue.Count;
            }
        }

        public void Enqueue(T item)
        {
            lock (this.queue)
            {
                if (this.Count > this.Limit)
                {
                    this.OnLimitReached(EventArgs.Empty);
                }

                this.queue.Enqueue(item);
                this.OnItemEnqueued(new ItemEventArgs<T>(item));
            }
        }

        public T Dequeue()
        {
            T item = this.queue.Dequeue();
            this.OnItemDequeued(new ItemEventArgs<T>(item));
            return item;
        }

        protected virtual void OnLimitReached(EventArgs e)
        {
            EventHandler tempHandler = this.LimitReached;
            if (null != tempHandler)
            {
                tempHandler(this, e);
            }
        }

        protected virtual void OnItemEnqueued( ItemEventArgs<T> e)
        {
            EventHandler<ItemEventArgs<T>> tempHandler = this.ItemEnqueued;
            if (null != tempHandler)
            {
                tempHandler(this, e);
            }
        }

        protected virtual void OnItemDequeued(ItemEventArgs<T> e)
        {
            EventHandler<ItemEventArgs<T>> tempHandler = this.ItemDequeued;
            if (null != tempHandler)
            {
                tempHandler(this, e);
            }
        }
    }
}