介绍开源的.net通信框架NetworkComms框架 源码分析（十二）PriorityQueue

原文网址： http://www.cnblogs.com/csdev

Networkcomms 是一款C# 语言编写的TCP/UDP通信框架  作者是英国人  以前是收费的 目前作者已经开源  许可是:Apache License v2

开源地址是:https://github.com/MarcFletcher/NetworkComms.Net

优先级队列

 /// <summary>
    /// Queue which contains features to add and remove items using a simple priority model.
    /// 优先级队列  包含一个简单的优先级类型
    /// </summary>
    /// <typeparam name="TValue">The type of this queue</typeparam>
    public class PriorityQueue<TValue>
    {
        /// <summary>
        /// Each internal queue in the array represents a priority level.
        /// We keep the priority associated with each item so that when eventually returned the
        /// priority can be easily included.
        /// 内部字典 以优先级作为索引项
        /// </summary>
        private Dictionary<QueueItemPriority,Queue<KeyValuePair<QueueItemPriority, TValue>>> internalQueues = null;

        /// <summary>
        /// The list of priorities used to handle incoming packets.
        /// 用于处理传入的数据包的优先级列表
        /// </summary>
        private QueueItemPriority[] QueueItemPriorityVals;

        /// <summary>
        /// The number of queues we store internally.
        /// 存储在内部的队列数量
        /// </summary>
        ;

        /// <summary>
        /// The total number of items currently in all queues
        /// 所有队列中的项目数
        /// </summary>
        ;

        /// <summary>
        /// Create a new instance of the priority queue.
        /// 创建一个新的优先级队列项实例
        /// </summary>
        public PriorityQueue()
        {
            var vals = Enum.GetValues(typeof(QueueItemPriority)) as int[];
            Array.Sort(vals);

            this.numDistinctPriorities = vals.Length;

            QueueItemPriorityVals = new QueueItemPriority[numDistinctPriorities];

            internalQueues = new Dictionary<QueueItemPriority,Queue<KeyValuePair<QueueItemPriority,TValue>>>(numDistinctPriorities);
            ; i < numDistinctPriorities; i++)
            {
                internalQueues[(QueueItemPriority)vals[i]] = new Queue<KeyValuePair<QueueItemPriority, TValue>>();
                QueueItemPriorityVals[i] = (QueueItemPriority)vals[i];
            }
        }

        /// <summary>
        /// Try adding an item to the priority queue.
        /// 添加项目到优先级队列项中
        /// </summary>
        /// <param name="item">Key is priority, lower number is lower priority, and value is TValue</param>
        /// <returns>True if an item was successfully added to the queue</returns>
        public bool TryAdd(KeyValuePair<QueueItemPriority, TValue> item)
        {
            lock (internalQueues)
            {
                internalQueues[item.Key].Enqueue(item);
                Interlocked.Increment(ref totalNumberQueuedItems);
            }

            return true;
        }

        /// <summary>
        /// Try removing an item from the priority queue
        /// 从优先级队列中删除相应的项目
        /// </summary>
        /// <param name="item">Key is priority, lower number is lower priority, and value is TValue</param>
        /// <returns>True if an item was successfully removed from the queue</returns>
        public bool TryTake(out KeyValuePair<QueueItemPriority, TValue> item)
        {
            // Loop through the queues in priority order. Higher priority first
            ; i >= ; i--)
            {
                // Lock the internal data so that the Dequeue
                // operation and the updating of m_count are atomic.
                lock (internalQueues)
                {
                    )
                    {
                        item = internalQueues[QueueItemPriorityVals[i]].Dequeue();
                        Interlocked.Decrement(ref totalNumberQueuedItems);
                        return true;
                    }
                    else
                        continue;
                }
            }

            // If we get here, we found nothing, return defaults
            item = , default(TValue));
            return false;
        }

        /// <summary>
        /// Try removing an item from the priority queue which has a priority of at least that provided.
        /// 从优先级队列中删除相应的项目   删除的项目至少具有参数指定的优先级
        /// </summary>
        /// <param name="minimumPriority">优先级  The minimum priority to consider</param>
        /// <param name="item">Key is priority, lower number is lower priority, and value is TValue</param>
        /// <returns>True if an item was successfully removed from the queue</returns>
        public bool TryTake(QueueItemPriority minimumPriority, out KeyValuePair<QueueItemPriority, TValue> item)
        {
            // Loop through the queues in priority order. Higher priority first
            ; i >= (int)minimumPriority; i--)
            {
                // Lock the internal data so that the Dequeue
                // operation and the updating of m_count are atomic.
                lock (internalQueues)
                {
                    )
                    {
                        item = internalQueues[QueueItemPriorityVals[i]].Dequeue();
                        Interlocked.Decrement(ref totalNumberQueuedItems);
                        return true;
                    }
                    else
                        continue;
                }
            }

            // If we get here, we found nothing, return defaults
            item = , default(TValue));
            return false;
        }

        /// <summary>
        /// The total number of items currently queued.
        /// 目前排队项目总数
        /// </summary>
        public int Count
        {
            get { return totalNumberQueuedItems; }
        }

        /// <summary>
        /// Copies queued items into the provided destination array. Highest priority items first descending until
        /// destination is full or there are no remaining items.
        /// 复制指定的优先级项目到数组中   从高优先级开始
        /// </summary>
        /// <param name="destination">The destination array</param>
        /// <param name="destStartingIndex">The position within destination to start copying to</param>
        public void CopyTo(KeyValuePair<QueueItemPriority, TValue>[] destination, int destStartingIndex)
        {
            if (destination == null) throw new ArgumentNullException("destination", "Provided KeyValuePair<QueueItemPriority, TValue>[] cannot be null.");
            ) throw new ArgumentOutOfRangeException("destStartingIndex", "Provided int must be positive.");

            int remaining = destination.Length;
            KeyValuePair<QueueItemPriority, TValue>[] temp = this.ToArray();
            for (int i = destStartingIndex; i < destination.Length && i < temp.Length; i++)
                destination[i] = temp[i];
        }

        /// <summary>
        /// 复制所有的优先级项目到数组中   从高优先级开始
        /// </summary>
        /// <returns></returns>
        public KeyValuePair<QueueItemPriority, TValue>[] ToArray()
        {
            KeyValuePair<QueueItemPriority, TValue>[] result;

            lock (internalQueues)
            {
                result = new KeyValuePair<QueueItemPriority, TValue>[this.Count];
                ;
                ; i >= ; i--)
                {
                    )
                    {
                        internalQueues[QueueItemPriorityVals[i]].CopyTo(result, index);
                        index += internalQueues[QueueItemPriorityVals[i]].Count;
                    }
                }
                return result;
            }
        }

        /// <summary>
        /// Gets a value indicating whether access to the PriorityQueue is synchronized (thread safe). Always returns true.
        /// 获取一个值，指示是否使用PriorityQueue是同步（线程安全）。始终返回true。
        /// </summary>
        public bool IsSynchronized
        {
            get { return true; }
        }

        /// <summary>
        /// Gets an object that can be used to synchronize access to the PriorityQueue. Throws an exception as all access is explicitly thread safe.
        /// 获取可用于同步访问一个对象的PriorityQueue  所有的访问都是现成安全时抛出异常 因为调用SyncRoot是不需要的
        /// </summary>
        public object SyncRoot
        {
            get { throw new Exception("All access to PriorityQueue is thread safe so calling SyncRoot() is unnecessary."); }
        }

        /// <summary>
        /// Clear the content of all queues
        /// 清除队列的内容
        /// </summary>
        public void Clear()
        {
            lock (internalQueues)
            {
                ; i < numDistinctPriorities; i++)
                    internalQueues[QueueItemPriorityVals[i]].Clear();
            }
        }
    }