using System;

using System.Collections;

using System.Collections.Concurrent;

using System.Collections.Generic;

​

public static class Program

{

    public static void Main()

    {

        var collection = new BlockingCollection<(string Server, int Priority)>(

            new ProducerConsumerPriorityQueue<string, int>());

​

        collection.Add(("Server-A", 20));

        collection.Add(("Server-B", 10));

        collection.Add(("Server-C", 20));

        collection.CompleteAdding();

​

        foreach (var (server, priority) in collection.GetConsumingEnumerable())

        {

            Console.WriteLine($"Server: {server}, Priority: {priority}");

        }

    }

​

    public class ProducerConsumerPriorityQueue<TElement, TPriority>

        : IProducerConsumerCollection<(TElement, TPriority)>

    {

        private readonly PriorityQueue<TElement, (TPriority, long)> _queue;

        private long _index = 0;

​

        public ProducerConsumerPriorityQueue(IComparer<TPriority> comparer = default)

        {

            comparer ??= Comparer<TPriority>.Default;

            _queue = new(Comparer<(TPriority, long)>.Create((x, y) =>

            {

                int result = comparer.Compare(x.Item1, y.Item1);

                if (result == 0) result = x.Item2.CompareTo(y.Item2);

                return result;

            }));

        }

​

        public int Count { get { lock (_queue) return _queue.Count; } }

​

        public bool TryAdd((TElement, TPriority) item)

        {

            lock (_queue) _queue.Enqueue(item.Item1, (item.Item2, ++_index));

            return true;

        }

​

        public bool TryTake(out (TElement, TPriority) item)

        {

            lock (_queue)

            {

                if (_queue.TryDequeue(out var element, out var priority))

                {

                    item = (element, priority.Item1); return true;

                }

                item = default; return false;

            }

        }

​

        public bool IsSynchronized => false;

​

        public object SyncRoot => throw new NotSupportedException();

​

        public (TElement, TPriority)[] ToArray()

            => throw new NotSupportedException();

​

        public void CopyTo((TElement, TPriority)[] array, int index)

            => throw new NotSupportedException();

​

        public void CopyTo(Array array, int index)

            => throw new NotSupportedException();

​

        public IEnumerator<(TElement, TPriority)> GetEnumerator()

            => throw new NotSupportedException();

​

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    }

}

​