The Weird and The Wonderful

Fandango90 wrote:

A true Primary Key is one created based on data "snippets" off other columns in the table.

Fandango90 wrote:

the same mistakes. Primary key every table with an auto-fill ID column

Fandango90 wrote:

Yes, you have a primary key, congratulations! But what's the point if you don't have a reference to the ID from another table?

Fandango90 wrote:

Did someone forget that the ID Primary Key column is a machine necessity, if at all? Like who care my next record starts with ID 2001!?

Fandango90 wrote:

A true Primary Key is one created based on data "snippets" off other columns in the table

raddevus wrote:

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

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Richard Deeming wrote:

It also seems that the order of searches has some effect. Try searching for 1st followed by 31st; then try 31st followed by 1s

Kornfeld Eliyahu Peter wrote:

seems to me a very bad practice to use a FIFO/LIFO oriented collection to anything else than push/pop

raddevus wrote:

all I have to do is call .First() on Dictionary when I want the oldest item.

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