using System;

using System.Collections.Immutable;

using System.Diagnostics;

using System.Threading.Channels;

using System.Threading;

using System.Threading.Tasks;

using System.Linq;

​

// https://chrlschn.medium.com/net-task-parallel-library-vs-system-threading-channels-6952a803f3da

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

        new Stc().Run();

    }

}

​

public class Stc

{

    public async void Run()

    {

        // Generate a set of 100 records, each with a random wait interval.

        var log = (object msg) => Console.WriteLine(msg);

​

        var workload = Enumerable

          .Range(0, 100)

          .Select(i => (Index: i, Delay: Random.Shared.Next(10, 50)))

          .ToImmutableArray();

​

        // Using System.Threading.Channels

        await InstrumentedRun("Channel", async () => {

          var channel = Channel.CreateUnbounded<int>();

​

          async Task Run(ChannelWriter<int> writer, int id, int delay) {

            await Task.Delay(delay);

            await writer.WriteAsync(id);

          }

​

          async Task Receive(ChannelReader<int> reader) {

            while (await reader.WaitToReadAsync()) {

              if (reader.TryRead(out var id)) {

                // No work here.

                //log($"  Completed {id}");

                  Console.WriteLine($"Completed {id}");

              }

            }

          }

​

          var receiveTask = Receive(channel.Reader);

          var processingTasks = workload

            .AsParallel()

            .Select(e => Run(channel.Writer, e.Index, e.Delay));

​

          await Task

            .WhenAll(processingTasks)

            .ContinueWith(_ => channel.Writer.Complete());

​

          await receiveTask;

        });

​

        // Using Parallel.For with concurrency of 4

        await InstrumentedRun("Parallel.For @ 4", () => {

          Parallel.For(0, 100, new ParallelOptions { MaxDegreeOfParallelism = 4 }, (index) => {

            Thread.Sleep(workload[index].Delay);

          });

​

          return Task.CompletedTask;

        });

​

        // Using Parallel.ForEachAsync with concurrency of 4

        await InstrumentedRun("Parallel.ForEachAsync @ 4", async () =>

          await Parallel.ForEachAsync(workload, new ParallelOptions { MaxDegreeOfParallelism = 4 }, async (item, cancel) => {

            await Task.Delay(item.Delay, cancel);

          })

        );

​

        // Using Parallel.ForEachAsync with concurrency of 40

        await InstrumentedRun("Parallel.ForEachAsync @ 40", async () =>

          await Parallel.ForEachAsync(workload, new ParallelOptions { MaxDegreeOfParallelism = 40 }, async (item, cancel) => {

            await Task.Delay(item.Delay, cancel);

          })

        );

​

        // Using Parallel.ForEachAsync with concurrency unset

        await InstrumentedRun("Parallel.ForEachAsync (Default)", async () =>

          await Parallel.ForEachAsync(workload, async (item, cancel) => {

            await Task.Delay(item.Delay, cancel);

          })

        );

​

        /*-----------------------------------------------------------

        * Supporting functions

        ---------------------------------------------------------*/

        async Task InstrumentedRun(string name, Func<Task> test) {

          var threadsAtStart = Process.GetCurrentProcess().Threads.Count;

          var timer = new Stopwatch();

          timer.Start();

          await test();

          timer.Stop();

          Console.WriteLine($"[{name}] = {timer.ElapsedMilliseconds}ms");

          Console.WriteLine($"  ⮑  {threadsAtStart} threads at start");

          Console.WriteLine($"  ⮑  {Process.GetCurrentProcess().Threads.Count} threads at end");

        }

​

        /*

        YMMV since each run uses a random workload.

​

        [Channel] = 68ms

          ⮑  8 threads at start

          ⮑  19 threads at end

        [Parallel.For @ 4] = 799ms

          ⮑  19 threads at start

          ⮑  19 threads at end

        [Parallel.ForEachAsync @ 4] = 754ms

          ⮑  19 threads at start

          ⮑  19 threads at end

        [Parallel.ForEachAsync @ 40] = 100ms

          ⮑  19 threads at start

          ⮑  19 threads at end

        [Parallel.ForEachAsync (Default)] = 384ms

          ⮑  19 threads at start

          ⮑  19 threads at end

        */

    }

}