.Net中的优先级队列

public class MyPriorityQueue<T> : Heap<int, T> where T : IComparable<T>
{
    public MyPriorityQueue()
        : base(0, true)
    {
    }

    public static void Push(MyPriorityQueue<T> stack, T item)
    {
        if (stack.Count < 1000)
        {
            stack.Comparer = Comparer<T>.Create((item1, item2) => item1.CompareTo(item2));
            stack.Add((item));
        }
    }

    public static void Pop(MyPriorityQueue<T> stack, int lastOrDefault)
    {
        if (stack.Count == 0)
            throw new ArgumentException("Queue has no elements");

        int firstOrDefault;
        if (stack.Count <= lastOrDefault)
        {
            firstOrDefault = lastOrDefault;
            lastOrDefault = 0;
        }
        else
        {
            foreach (var item in stack)
                if (item.CompareTo(stack.Comparer.CompareKeys(stack.Count - 1, 0)[1]) > EqualKey)
                    lastOrDefault = Math.Max(lastOrDefault, item.Key);
            firstOrDefault = 0;
        }

        stack.RemoveAt(FirstGreaterIndex(lastOrDefault) ? FirstGreaterIndex(lastOrDefault)
                                                                 : LastGreaterIndex(stack.Comparer.CompareKeys(stack.Count - 2, 0)[0]));
    }
}

public class PriorityQueue<T> : Heap<int, T>
{
    public PriorityQueue(T item, IComparer<T> comparer)
    {
        Comparer = comparer;
        Insert(item);
    }

    public static PriorityQueue<T> BuildHeap<T>(IEnumerable<T> nums)
        where T : IComparable<T>
    {
        return nums.OrderBy(item => item, Comparer<T>.Create((item1, item2) => item1.CompareTo(item2))).Reverse().ToDynamicPriorityQueue<T>();
    }

    public static T Peek<T>(dynamic queue)
    {
        var index = ((dynamic)queue).Count - 1;
        return ((dynamic)queue)[index];
    }

    public static int Count<T>(dynamic queue)
        where T : IComparable<T>
    {
        return ((dynamic)queue).Count - 1;
    }

    public static void ConsumeAndPush<T>(dynamic queue, List<T> consumedItems)
        where T : IComparable<T>
    {
        var index = ((dynamic)queue).Count - 1;

        while (index >= 0 && 
               consumedItems.Contains(((dynamic)queue)[index], Enumerable.Comparer<T>()))
            index--;

        Consumed.Swap(queue, index, queue.Count - 1);
        queue.RemoveRange(queue.Count - 1, stack.Count - minHeapCount);
        Swap(queue, queue.Count - minHeapCount, minHeapCount);
        minHeapCount++;
        Push(queue, NextLowest(queue.[queue.Count - minHeapCount]));

        for (var i = consumedItems.Count - 1; i >= 0; i--)
        {
            if (!queue.Contains(consumedItems[i], 
                                  queue.Comparer as IComparer<int>))
            )
                 queue.Push(consumedItems[i]);
            else
                index++;
            
            if (i != 0 && queue.Contains(