[corefx注释说]-System.Collections.Generic.Queue

为了节省时间，只写一些关注的方法好了，剩下的可以MSDN嘛XD

首先是声明部分，表示为队列是一个可用于枚举的只读集合

    [DebuggerTypeProxy(typeof(QueueDebugView<>))]
    [DebuggerDisplay("Count = {Count}")]
    public class Queue<T> : IEnumerable<T>,
        System.Collections.ICollection,
        IReadOnlyCollection<T>

字段

        private T[] _array;
        private int _head;       // First valid element in the queue
        private int _tail;       // Last valid element in the queue
        private int _size;       // Number of elements.
        private int _version;
        private Object _syncRoot;

        private const int MinimumGrow = 4;
        private const int GrowFactor = 200;  // double each time
        private const int DefaultCapacity = 4;

这里有“递增因子”的概念存在，因此可以从中学习到对于队列这样的数据结构，通过使用数组，如何在“满队”情况下扩充空间。

构造方法

        // Creates a queue with room for capacity objects. The default initial
        // capacity and grow factor are used.
        /// 
        public Queue()
        {
            _array = Array.Empty();
        }

        // Creates a queue with room for capacity objects. The default grow factor
        // is used.
        //
        /// 
        public Queue(int capacity)
        {
            if (capacity < 0)
                throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_NeedNonNegNumRequired);
            _array = new T[capacity];
        }

        // Fills a Queue with the elements of an ICollection.  Uses the enumerator
        // to get each of the elements.
        //
        /// 
        public Queue(IEnumerable collection)
        {
            if (collection == null)
                throw new ArgumentNullException("collection");

            _array = new T[DefaultCapacity];

            using (IEnumerator en = collection.GetEnumerator())
            {
                while (en.MoveNext())
                {
                    Enqueue(en.Current);
                }
            }
        }

提供三种构造方法：

1. 构造空队列
2. 构造指定空间容量的队列
3. 复制已有队列（特别注意这个，很有意思）

属性

        /// 
        public int Count
        {
            get { return _size; }
        }

        /// 
        bool System.Collections.ICollection.IsSynchronized
        {
            get { return false; }
        }

        Object System.Collections.ICollection.SyncRoot
        {
            get
            {
                if (_syncRoot == null)
                {
                    System.Threading.Interlocked.CompareExchange