using System;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Generic;

using System.Linq;

using System.Collections.Concurrent;

​

public static class Program

{

    static void Main()

    {

        ThreadPool.GetMinThreads(out int workerThreads, out _);

        Console.WriteLine($"WorkerThreads: {workerThreads}, ProcessorCount: {Environment.ProcessorCount}");

        ThreadPool.SetMinThreads(10, 10);

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Starting");

        Enumerable.Range(1, 10)

        .ParallelForEachAsync_HouseCat(async x =>

        //.ParallelForEachAsync_StephenToub(async x =>

        {

            Thread.Sleep(1000); // Simulate a badly behaving async delegate

            //await Task.Delay(1000); // Simulate a normal async behavior

            await Task.CompletedTask;

            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Processed #{x}");

        }, maxDoP: 10).Wait();

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} Finished");

    }

​

    public static Task ParallelForEachAsync_HouseCat<T>(this IEnumerable<T> source,

        Func<T, Task> funcBody, int maxDoP = 4)

    {

        async Task AwaitPartition(IEnumerator<T> partition)

        {

            using (partition)

            {

                while (partition.MoveNext())

                { await funcBody(partition.Current); }

            }

        }

​

        return Task.WhenAll(

            Partitioner

                .Create(source)

                .GetPartitions(maxDoP)

                .AsParallel()

                .Select(p => AwaitPartition(p)));

    }

​

    public static Task ParallelForEachAsync_StephenToub<T>(this IEnumerable<T> source,

        Func<T, Task> funcBody, int maxDoP = 4)

    {

        Task AwaitPartition(IEnumerator<T> partition)

        {

            return Task.Run(async () =>

            {

                using (partition)

                {

                    while (partition.MoveNext())

                    { await funcBody(partition.Current); }

                }

            });

        }

​

        return Task.WhenAll(

            Partitioner

                .Create(source)

                .GetPartitions(maxDoP)

                .Select(p => AwaitPartition(p)));

    }

​

}

​