/// <summary>
        /// Checks if an item is in the queue.
        /// </summary>
        /// <param name="item">The object to check for in the queue.</param>
        /// <returns>True if the item is found, false otherwise.</returns>
        public bool Contains(T item)
        {
            // Use the default equality comparer for the type T.
            EqualityComparer <T> comparer = EqualityComparer <T> .Default;
            QueueNode <T>        node     = _first;

            // If there are items in the queue.
            if (node != null)
            {
                if (item != null)
                {
                    do
                    {
                        // Use the equality comparer if the item isn't null.
                        if (comparer.Equals(node.Value, item))
                        {
                            return(true);
                        }
                        node = node.Next;
                    } while (node != null);
                }
                else
                {
                    do
                    {
                        if (node.Value == null)
                        {
                            return(true);
                        }
                        node = node.Next;
                    } while (node != null);
                }
            }

            return(false);
        }
 internal QueueNode(T value, QueueNode <T> next, QueueNode <T> previous) : this(value)
 {
     Next     = next;
     Previous = previous;
 }
 public void Reset()
 {
     Current = default(T);
     _node   = _queue._first;
     _index  = 0;
 }
        /// <summary>
        /// Copies the elements of the <see cref="LinkedListQueue{T}"/> to an <see cref="Array"/>,
        /// starting at a particular <see cref="Array"/> index.
        /// </summary>
        /// <param name="array">
        /// The one-dimensional <see cref="Array"/> that is the destination of the elements copied
        /// from <see cref="LinkedListQueue{T}"/>. The <see cref="Array"/> must have zero-based indexing.
        /// </param>
        /// <param name="index">The zero-based index in array at which copying begins.</param>
        void ICollection.CopyTo(Array array, int index)
        {
            if (_count == 0)
            {
                return;
            }

            if (array == null)
            {
                throw new ArgumentNullException(nameof(array));
            }

            if ((uint)index >= array.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(index), _StartIndexZeroGreaterMessage);
            }

            if (array.Rank != 1)
            {
                throw new ArgumentException(_OnlySingleDimArraysMessage, nameof(array));
            }

            if (array.GetLowerBound(0) != 0)
            {
                throw new ArgumentException(_ArrayNonZeroLBMessage, nameof(array));
            }

            if (array.Length - index < _count)
            {
                throw new ArgumentOutOfRangeException(nameof(array), _DestArraySizeTooSmallMessage);
            }

            if (array is T[] testArray)
            {
                CopyTo(testArray, index);
            }
            else
            {
                Type targetType = array.GetType().GetElementType();
                Type sourceType = typeof(T);
                if (!(targetType.IsAssignableFrom(sourceType) || sourceType.IsAssignableFrom(targetType)))
                {
                    throw new ArgumentException(_InvalidArrayTypeMessage, nameof(array));
                }

                if (!(array is object[] objects))
                {
                    throw new ArgumentException(_InvalidArrayTypeMessage, nameof(array));
                }

                QueueNode <T> node = _first;
                try
                {
                    if (node != null)
                    {
                        do
                        {
                            objects[index++] = node.Value;
                            node             = node.Next;
                        } while (node != null);
                    }
                }
                catch (ArrayTypeMismatchException)
                {
                    throw new ArgumentException(_InvalidArrayTypeMessage, nameof(array));
                }
            }
        }