• 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)

    出栈

  • 相关阅读:
    Console
    在IOS10系统中无法定位问题
    c# js 时间
    ConcurrentDictionary,ConcurrentStack,ConcurrentQueue
    转 控件拖动 未验证
    消息处理模拟点击
    C ProcessAsUser
    SessionChange
    installer
    mysql主从同步配置
  • 原文地址:https://www.cnblogs.com/yaosj/p/11138020.html
Copyright © 2020-2023  润新知