C#的隊列(Queue，ConcurrentQueue)和堆棧(Stack，ConcurrentStack)

一、Queue

表示對象的先進先出(FIFO)集合，非線程安全

常用方法
Dequeue	入隊
Enqueue	出隊
Contains	隊列中是否存在某元素
Clear	清空隊列

 

封裝：

    /// <summary>
    /// QueuePool（先進先出）
    /// </summary>
    /// <typeparam name="T">表示泛型，QueuePool中元素的類型</typeparam>
    public class QueuePool<T>
    {
        private Queue<T> myPool = null;

        /// <summary>
        /// 按照設定的大小初始化 QueuePool 
        /// </summary>
        /// <param name="capacity"> QueuePool 最大容量</param>
        public QueuePool(int capacity)
        {
            myPool = new Queue<T>(capacity);
        }

        /// <summary>
        /// 向 QueuePool 中添加對象
        /// </summary>
        /// <param name="item">待添加對象</param>
        public void Enqueue(T item)
        {
            if (item == null)
                throw new ArgumentNullException("Items added to a QueuePool cannot be null");

            lock (myPool)
            {
                myPool.Enqueue(item);
            }
        }

        /// <summary>
        /// 向 QueuePool 中提取對象，並移除該對象
        /// </summary>
        /// <returns>提取出來的對象</returns>
        public T Dequeue()
        {
            lock (myPool)
            {
                return myPool.Dequeue();
            }
        }

        /// <summary>
        /// 向 QueuePool 中提取對象，但不移除該對象
        /// </summary>
        /// <returns>提取出來的對象</returns>
        public T Peek()
        {
            lock (myPool)
            {
                return myPool.Peek();
            }
        }

        /// <summary>
        /// 從 QueuePool 中移除所有的對象。
        /// </summary>
        public void Clear()
        {
            lock (myPool)
            {
                myPool.Clear();
            }
        }

        /// <summary>
        /// 判斷某個對象是否在 QueuePool 中
        /// </summary>
        public bool Contains(T item)
        {
            lock (myPool)
            {
                return myPool.Contains(item);
            }
        }

        /// <summary>
        /// 獲取 QueuePool 中包含的對象個數
        /// </summary>
        public int Count { get => myPool.Count(); }
    }

　　

二、Stack

表示對象的簡單后進先出 (LIFO) 非泛型集合，非線程安全

 

常用方法
Push	入棧
Pop	出棧
Contains	堆棧中是否存在某元素
Clear	清空堆棧

封裝：

    /// <summary>
    /// StackPool（后進先出）
    /// </summary>
    /// <typeparam name="T">表示泛型，StackPool中元素的類型</typeparam>
    public class StackPool<T>
    {
        private Stack<T> myPool = null;

        /// <summary>
        /// 按照設定的大小初始化 StackPool 
        /// </summary>
        /// <param name="capacity"> StackPool 最大容量</param>
        public StackPool(int capacity)
        {
            myPool = new Stack<T>(capacity);
        }

        /// <summary>
        /// 向 StackPool 中添加對象
        /// </summary>
        /// <param name="item">待添加對象</param>
        public void Push(T item)
        {
            if (item == null)
                throw new ArgumentNullException("Items added to a StackPool cannot be null");

            lock (myPool)
            {
                myPool.Push(item);
            }
        }

        /// <summary>
        /// 向 StackPool 中提取對象，並移除該對象
        /// </summary>
        /// <returns>提取出來的對象</returns>
        public T Pop()
        {
            lock (myPool)
            {
                return myPool.Pop();
            }
        }

        /// <summary>
        /// 向 StackPool 中提取對象，但不移除該對象
        /// </summary>
        /// <returns>提取出來的對象</returns>
        public T Peek()
        {
            lock (myPool)
            {
                return myPool.Peek();
            }
        }

        /// <summary>
        /// 從 StackPool 中移除所有的對象。
        /// </summary>
        public void Clear()
        {
            lock (myPool)
            {
                myPool.Clear();
            }
        }

        /// <summary>
        /// 判斷某個對象是否在 StackPool 中
        /// </summary>
        public bool Contains(T item)
        {
            lock (myPool)
            {
                return myPool.Contains(item);
            }
        }

        /// <summary>
        /// 獲取 StackPool 中包含的對象個數
        /// </summary>
        public int Count { get => myPool.Count(); }
    }

　　

三、ConcurrentQueue

表示線程安全的先進先出 (FIFO) 集合

常用方法
Dequeue	入隊
TryDequeue(T)	出隊

 

四、ConCurrentStack

表示線程安全的后進先出 (LIFO) 集合

常用方法
Push	入棧
TryPop(T)	出棧