.NET Fiddle

CSharp · Console

/Program.cs

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();
    }
}
;