通用類型參數作為類型參數，並在C＃函數之一中新增了通用類型

Question

我想實現一個優先級隊列，可以通過它指定隊列的類型（通用隊列或唯一隊列）。

public class PriorityQueue<TItem, TKey, TQueue> : IEnumerable<TItem>
    where TKey : IComparable
    where TQueue : Queue<TItem>, new ()
{
    private readonly Func<TItem, TKey> _keySelector;

    private readonly SortedDictionary<TKey, TQueue> _data = new SortedDictionary<TKey, TQueue>();

    public PriorityQueue(Func<TItem, TKey> keySelector)
    {
        _keySelector = keySelector;
    }

    public void Enqueue(TItem item)
    {
        var key = _keySelector(item);

        if (!_data.ContainsKey(key))
        {
            _data.Add(key, new TQueue());
        }

        var queue = _data[key];
        queue.Enqueue(item);
    }

    public TItem Dequeue()
    {
        if (IsEmpty)
        {
            throw new ArgumentException("Queue is EMPTY");
        }

        var key = _data.Keys.First();
        var queue = _data[key];

        var item = queue.Dequeue();
        if (queue.Count == 0)
        {
            _data.Remove(key);
        }

        return item;
    }

    public bool IsEmpty => _data.Count == 0;

    private int Count
    {
        get
        {
            var count = 0;
            foreach (var key in _data.Keys)
            {
                count += _data[key].Count;
            }

            return count;
        }
    }

    public void Clear()
    {
        _data.Clear();
    }


    public IEnumerator<TItem> GetEnumerator()
    {
        return new Enumerator(_data);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    private class Enumerator : IEnumerator<TItem>
    {
        private readonly SortedDictionary<TKey, TQueue> _dictionary;
        private readonly int _dictionaryCount;
        private int _currentPosition;

        public Enumerator(SortedDictionary<TKey, TQueue> data)
        {
            _dictionary = data;
            _dictionaryCount = DictionaryCount;
            _currentPosition = 0;
            Current = default(TItem);
        }

        private int DictionaryCount
        {
            get
            {
                var count = 0;
                foreach (var key in _dictionary.Keys)
                {
                    count += _dictionary[key].Count;
                }

                return count;
            }
        }

        public void Dispose()
        {

        }

        public bool MoveNext()
        {
            if (_currentPosition >= _dictionaryCount)
            {
                return false;
            }

            Current = GetCurrent();
            _currentPosition++;

            return true;
        }

        public void Reset()
        {
            _currentPosition = 0;
        }

        public TItem Current { get; private set; }

        private TItem GetCurrent()
        {
            var sum = 0;
            var item = default(TItem);

            foreach (var key in _dictionary.Keys)
            {
                var queue = _dictionary[key];

                sum += queue.Count;

                if (sum > _currentPosition)
                {
                    item = queue.Take(queue.Count - (sum - _currentPosition) + 1).Last();
                    break;
                }
            }

            return item;
        }

        object IEnumerator.Current => Current;
    }
}

和唯一的隊列

public class UniqueQueue<T> : Queue<T>
{
    private HashSet<T> _hashSet;

    public UniqueQueue()
    {
        _hashSet = new HashSet<T>();
    }

    public new void Enqueue(T item)
    {
        if (_hashSet.Add(item))
        {
            base.Enqueue(item);
        }
    }

    public new T Dequeue()
    {
        var item = base.Dequeue();
        _hashSet.Remove(item);
        return item;
    }

    public new void Clear()
    {
        _hashSet.Clear();
        base.Clear();
    }
}

但是在單元測試中，它失敗並顯示以下代碼

       [TestMethod]
    public void TestPriorityUniqueQueue()
    {
        var puq = new PriorityQueue<Node, int, UniqueQueue<Node>>(node => node.Key);

        var node1 = new Node(1, "One");
        var node2 = new Node(2, "Two");
        var node3 = new Node(1, "One 1");

        puq.Enqueue(node1);
        puq.Enqueue(node1);
        puq.Enqueue(node1);
        puq.Enqueue(node2);
        puq.Enqueue(node3);

        var list = new List<Node>();
        foreach (var node in puq)
        {
            list.Add(node);
        }

        Assert.AreEqual(list[0], node1);
        **Assert.AreEqual(list[1], node3);**
        Assert.AreEqual(list[2], node2);

        puq.Dequeue();
        puq.Dequeue();
        puq.Dequeue();

        Assert.IsTrue(puq.IsEmpty);
    }

我調試了測試用例，並發現在調用puq.Enqueue（node1）時，它從Queue而不是從UniqueueQueue中調用了Enqueue（）函數。 但是，當我調試時，我發現在PriorityQueue的Enqueue中，該變量是UniqueQueue的類型，但它沒有調用UniqueQueue的Enqueue（）。 我真的很想知道為什么，或者給我一些建議以解決這個問題？

它在粗體行中失敗，並且堆棧跟蹤為

Assert.AreEqual失敗。 預期：。 實際：。 在ToolsTests.PriorityQueueTest.TestPriorityUniqueQueue（）中的位置somefolder \\ ToolsTests \\ PriorityQueueTests.cs：行號118

PriorityQueue <>。Enqueue（）方法的隊列變量的調試信息

Answer 1

通用類型參數TQueue<T>的類型應為Queue<T>因為您是在PriorityQueue的通用約束中定義的：

 where TQueue : Queue<TItem>, new ()

現在，只要您的代碼通過：

_data.Add(key, new TQueue());

這將創建一個實例Queue<T>而不是UniqueQueue<T>因此它永遠不會達到Enqueue的方法UniqueQueue<T>因為它調用了Enqueue的方法Queue<T>

這樣做的原因是由於您提供了一般約束（上面的第一個代碼塊）。 它根本不知道UniqueQueue<T>類型，而是Queue<T>類型，因為那是PriorityQueue<TItem, TKey, TQueue>期望的（因為您這樣“告訴”了他）。 因此，無論何時執行new TQueue() ，都會實例化一個新的Queue<T>對象而不是UniqueQueue<T> 。

為了使測試通過，並且PriorityQueue<TItem, TKey, TQueue>實際使用UniqueQueue<T> ，必須在通用約束中顯式指定要使用UniqueQueue<T> ：

where TQueue : UniqueQueue<TItem>, new()