The Weird and The Wonderful

public sealed class UniqueQueue<T> : IEnumerable<T>, IDisposable
{
    private readonly Queue<T> _queue = new Queue<T>();
    private readonly HashSet<T> _set = new HashSet<T>();
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    
    public int Count
    {
        get
        {
            bool lockTaken = false;
            try
            {
                lockTaken = _lock.TryEnterReadLock(Timeout.Infinite);
                if (!lockTaken) throw new InvalidOperationException();
                
                return _queue.Count;
            }
            finally
            {
                if (lockTaken)
                {
                    _lock.ExitReadLock();
                }
            }
        }
    }
    
    public void Dispose()
    {
        _lock.Dispose();
    }
    
    public T Dequeue()
    {
        bool lockTaken = false;
        try
        {
            lockTaken = _lock.TryEnterWriteLock(Timeout.Infinite);
            if (!lockTaken) throw new InvalidOperationException();
            
            T oldestItem = _queue.Dequeue();
            _set.Remove(oldestItem);
            return oldestItem;
        }
        finally
        {
            if (lockTaken)
            {
                _lock.ExitWriteLock();
            }
        }
    }
    
    public void AddRange(IEnumerable<T> itemsToAdd)
    {
        if (itemsToAdd == null) throw new ArgumentNullException(nameof(itemsToAdd));
        
        bool lockTaken = false;
        try
        {
            lockTaken = _lock.TryEnterWriteLock(Timeout.Infinite);
            if (!lockTaken) throw new InvalidOperationException();
            
            foreach (T item in itemsToAdd)
            {
                if (_set.Add(item))
                {
                    _queue.Enqueue(item);
                }
            }
        }
        finally
        {
            if (lockTaken)
            {
                _lock.ExitWriteLock();
            }
        }
    }
    
    public UniqueQueueEnumerator GetEnumerator()
    {
        T[] copyOfItems = Array.Empty<T>();
        
        bool lockTaken = false;
        try
        {
            lockTaken = _lock.TryEnterReadLock(Timeout.Infinite);
            if (!lockTaken) throw new InvalidOperationException();
            
            copyOfItems = new T[_queue.Count];
            _queue.CopyTo(copyOfItems, 0);
        }
        finally
        {
            if (lockTaken)
            {
                _lock.ExitReadLock();
            }
        }
        
        return new UniqueQueueEnumerator(copyOfItems);
    }
    
    IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    
    public struct UniqueQueueEnumerator : IEnumerator<T>
    {
        private readonly T[] _items;
        private int _position;
        
        public UniqueQueueEnumerator(T[] items)
        {
            _items = items;
            _position = -1;
        }
        
        void IDisposable.Dispose()
        {
        }
        
        public void Reset()
        {
            if (_items == null) throw new InvalidOperationException();
            _position = -1;
        }
        
        public bool MoveNext()
        {
            if (_items == null) return false;
            return ++_position < _items.Length;
        }
        
        public T Current
        {
            get
            {
                if (_items == null) throw new InvalidOperationException();
                if (0 > _position || _position >= _items.Length) throw new InvalidOperationException();
                return _items[_position];
            }
        }
        
        object IEnumerator.Current => Current;
    }
}

raddevus wrote:

I am actually using the ConcurrentQueue and ConcurrentDictionary which are thread-protected automatically

raddevus wrote:

I needed to know that when I went to determine if the queue already had the item, if it would return faster when the item was found at the top (next item out) versus found at the bottom (last out position).

I assumed, but wasn't sure.
This code gives a good definitive answer

kmoorevs wrote:

fixed

Tomz_KV wrote:

Is decimal portion not required?

var ccList = Enumerable.Range(0,1);
var objects = ccList.Select(x=> (object)cc);
foo.Items = objects.ToArray();

BillW33 wrote:

That code will work, but, like my signature says, that doesn't mean it is a good way to do it.

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

Nelek wrote:

And I suppose this is exactly why he is posting it in this forum

foo.items = new List<object>() { cc }.ToArray();