Adding TryDequeue method to Queue. Resolves #4316

Author: alphonsekurian

src/System.Collections/src/System/Collections/Generic/Queue.cs

@@ -225,15 +225,30 @@ IEnumerator IEnumerable.GetEnumerator()
         // InvalidOperationException.
         public T Dequeue()
         {
-            if (_size == 0)
+            T removed;
+            if (!TryDequeue(out removed))
                 throw new InvalidOperationException(SR.InvalidOperation_EmptyQueue);
 
-            T removed = _array[_head];
+            return removed;
+        }
+
+        // Removes the object at the head of the queue and assigns to out parameter passed
+        //if queue is not empty and returns true.
+        // If the queue is empty, this method assigns default value to out parameter and returns false.
+        public bool TryDequeue(out T item)
+        {
+            if (_size == 0)
+            {
+                item = default(T);
+                return false;
+            }
+
+            item = _array[_head];
             _array[_head] = default(T);
             MoveNext(ref _head);
             _size--;
             _version++;
-            return removed;
+            return true;
         }
 
         // Returns the object at the head of the queue. The object remains in the

src/System.Collections/tests/Generic/Queue/Queue.Generic.Tests.cs

@@ -95,6 +95,93 @@ public void Queue_Generic_Constructor_int_Negative_ThrowsArgumentOutOfRangeExcep
 
         #endregion
 
+        #region TryDequeue
+
+        [Fact]
+        public void Queue_Generic_TryDequeue_OnEmptyQueue_ReturnsFalse()
+        {
+            T value;
+            Assert.False(() => new Queue<T>().TryDequeue(out value));
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidCollectionSizes))]
+        public void Queue_Generic_TryDequeue_OnNonEmptyQueue_ReturnsTrue(int count)
+        {
+            Queue<T> q = GenericQueueFactory(count);
+            T value;
+            Assert.True(() => q.TryDequeue(out value));
+        }
+
+        [Fact]
+        public void Queue_Generic_TryDequeue_OnEmptyQueue_GivesDefaultValue()
+        {
+            T value;
+            new Queue<T>().TryDequeue(out value);
+            //Out argument has default value of T when queue is empty
+            Assert.Equal(default(T), value);
+        }
+
+        [Theory]
+        [InlineData(0, 5)]
+        [InlineData(1, 1)]
+        [InlineData(3, 100)]
+        public void Queue_Generic_TryDequeue_EnqueueTryDequeue(int capacity, int items)
+        {
+            int seed = 53134;
+            T itemRemovedFromQueue;
+            var q = new Queue<T>(capacity);
+            Assert.Equal(0, q.Count);
+
+            // Enqueue some values and make sure the count is correct
+            List<T> source = (List<T>)CreateEnumerable(EnumerableType.List, null, items, 0, 0);
+            foreach (T val in source)
+            {
+                q.Enqueue(val);
+            }
+            Assert.Equal(source, q);
+
+            // Dequeue to make sure the values are removed in the right order and the count is updated
+            for (int i = 0; i < items; i++)
+            {
+                T itemToRemove = source[0];
+                source.RemoveAt(0);
+                q.TryDequeue(out itemRemovedFromQueue);
+                Assert.Equal(itemToRemove, itemRemovedFromQueue);
+                Assert.Equal(items - i - 1, q.Count);
+            }
+
+            // Can't dequeue when empty
+            Assert.False(() => q.Dequeue(out itemRemovedFromQueue));
+
+            // But can still be used after a failure and after bouncing at empty
+            T itemToAdd = CreateT(seed++);
+            q.Enqueue(itemToAdd);
+            q.TryDequeue(out itemRemovedFromQueue);
+            Assert.Equal(itemToAdd, itemRemovedFromQueue);
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidCollectionSizes))]
+        public void Queue_Generic_TryDequeue_TryDequeueAfterClear(int count)
+        {
+            Queue<T> q = GenericQueueFactory(count);
+            T value;
+            //Can remove an item from non empty queue
+            Assert.True(() => q.TryDequeue(out value));
+
+            //can't dequeue after clearing the queue
+            q.Clear();
+            Assert.False(() => q.TryDequeue(out value));
+
+            // But can still be used after a failure and after bouncing at empty
+            T itemToAdd = CreateT(seed++);
+            q.Enqueue(itemToAdd);
+            Assert.True(() => q.TryDequeue(out value));
+        }
+
+        #endregion
+
         #region Dequeue
 
         [Theory]