Add the ordering demonstration: own-queue LIFO drain and a steal from a dedicated thread

DrainOwnQueue fills a bag and drains it on the same thread, which returns the
items last in, first out. DrainStolenQueue fills the bag on one dedicated thread
and drains it on another, so the consumer steals from the head of the producer's
queue and the items come back oldest first.

Both use dedicated Thread objects with Join(), never Task.Run: the pool is free
to hand the producer and the consumer to the same thread, which makes the
consumer pop its own queue LIFO instead of stealing and the assertion
intermittently red.

Two tests added. The suite runs 10 of 10 on five consecutive runs.

Author: vladimir-pecanac-main

collections-csharp/ConcurrentBagInCSharp/ConcurrentBagInCSharp/ConcurrentBagDemo.cs

@@ -82,6 +82,54 @@ public static void AccessItemFromAConcurrentBagConcurrently(ConcurrentBag<int> b
             });
         }
 
+        public static List<int> DrainOwnQueue()
+        {
+            var bag = new ConcurrentBag<int>();
+            for (var i = 1; i <= 5; i++)
+            {
+                bag.Add(i);
+            }
+
+            var taken = new List<int>();
+            while (bag.TryTake(out var item))
+            {
+                taken.Add(item);
+            }
+
+            return taken;
+        }
+
+        public static List<int> DrainStolenQueue()
+        {
+            var bag = new ConcurrentBag<int>();
+            var taken = new List<int>();
+
+            // Dedicated threads, never Task.Run: the thread pool is free to hand both pieces of
+            // work to the same thread, and a consumer running on the producer's thread pops its
+            // own queue last in, first out instead of stealing.
+            var producer = new Thread(() =>
+            {
+                for (var i = 0; i < 5; i++)
+                {
+                    bag.Add(i);
+                }
+            });
+            producer.Start();
+            producer.Join();
+
+            var consumer = new Thread(() =>
+            {
+                while (bag.TryTake(out var item))
+                {
+                    taken.Add(item);
+                }
+            });
+            consumer.Start();
+            consumer.Join();
+
+            return taken;
+        }
+
         public static int[] ConcurrentBagToArrayMethod(ConcurrentBag<int> bag)
         {
             return bag.ToArray();

collections-csharp/ConcurrentBagInCSharp/Tests/ConcurrentBagInCSharpTest.cs

@@ -63,6 +63,22 @@ public void GivenAConcurrentBag_WhenConvertingToAnArray_ThenReturnsAnArray()
             Assert.NotEmpty(result);
         }
 
+        [Fact]
+        public void GivenAConcurrentBagFilledOnOneThread_WhenDrainingOnThatThread_ThenReturnsItemsLastInFirstOut()
+        {
+            var result = ConcurrentBagDemo.DrainOwnQueue();
+
+            Assert.Equal(new List<int> { 5, 4, 3, 2, 1 }, result);
+        }
+
+        [Fact]
+        public void GivenAConcurrentBagFilledOnOneThread_WhenDrainingOnADifferentThread_ThenReturnsItemsOldestFirst()
+        {
+            var result = ConcurrentBagDemo.DrainStolenQueue();
+
+            Assert.Equal(new List<int> { 0, 1, 2, 3, 4 }, result);
+        }
+
         [Fact]
         public void GivenAConcurrentBag_WhenClearingAConcurrentBag_ThenReturnsAnEmptyConcurrentBag()
         {