using System;

using System.Linq;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Threading.Tasks;

using System.Diagnostics;

using System.Threading;

​

public class Program

{

    private static readonly TimeSpan IODuration = TimeSpan.FromMilliseconds(10);

    private static readonly IDictionary<string, string> _database = new ConcurrentDictionary<string, string>();

    public static void Main()

    {

        var timer = Stopwatch.StartNew();

        Insert();

        timer.Stop();

        Console.WriteLine("Sequencial: {0} ms", timer.ElapsedMilliseconds);

        timer = Stopwatch.StartNew();

        InsertBulkParallel();

        timer.Stop();

        Console.WriteLine("Parallel Library: {0} ms", timer.ElapsedMilliseconds);

        timer = Stopwatch.StartNew();

        InsertBulkAsync();

        timer.Stop();

        Console.WriteLine("Async Library: {0} ms", timer.ElapsedMilliseconds);

    }

    public static void Insert()

    {

        var list = GenerateItems();

        var count = list.Count();

        for(var i = 0; i < count; i++) 

        {

            InsertInDatabaseAsync($"{i}", list.ElementAt(i)).GetAwaiter().GetResult();

        }

    }

    public static void InsertBulkParallel()

    {

        var list = GenerateItems();

        var count = list.Count();

        Parallel.For(0, count, (i) => 

        {

            InsertInDatabaseAsync($"{i}", list.ElementAt(i)).GetAwaiter().GetResult();

        });

    }

    public static void InsertBulkAsync()

    {

        var list = GenerateItems();

        var count = list.Count();

        ForEachAsync(count, list, async (item, index) => 

        {

            await InsertInDatabaseAsync($"{index}", item);

        }).GetAwaiter().GetResult();

    }

    private static async Task InsertInDatabaseAsync(string index, string item)

    {

        await Task.Delay(IODuration);

        _database[index] = item;

    }

    private static IEnumerable<string> GenerateItems(int count = 100)

    {

        var list = new List<string>();

        for(var i = 0; i< count; i++)

        {

            list.Add("{\"id\":1}");

        }

        return list;

    }

    private static async Task ForEachAsync<T>(int maxTaskCount, IEnumerable<T> enumerable, Func<T, int, Task> asyncFunc, Action<Exception> onException = null, CancellationToken cancellationToken = default)

        {

            using var semaphore = new SemaphoreSlim(initialCount: maxTaskCount, maxCount: maxTaskCount);

            object lockObject = new object();

            var exceptions = new List<Exception>();

            var tasks = new Task[enumerable.Count()];

            int i = 0;

​

            try

            {

                foreach (var t in enumerable)

                {

                    await semaphore.WaitAsync(cancellationToken);

                    tasks[i++] = Task.Run(

                        async () =>

                        {

                            try

                            {

                                await asyncFunc(t, i);

                            }

                            catch (Exception e)

                            {

                                if (onException != null)

                                {

                                    lock (lockObject)

                                    {

                                        onException.Invoke(e);

                                    }

                                }

                                throw;

                            }

                            finally

                            {

                                semaphore.Release();

                            }

                        }, cancellationToken);

​

                    if (cancellationToken.IsCancellationRequested)

                    {

                        break;

                    }

                }

            }

            catch (OperationCanceledException e)

            {

                exceptions.Add(e);

            }

​

            foreach (var t in tasks)

            {

                if (cancellationToken.IsCancellationRequested)

                {

                    break;

                }

                try

                {

                    await t;

                }

                catch (Exception e)

                {

                    exceptions.Add(e);

                }

            }

​

            if (exceptions.Any())

            {

                throw new AggregateException(exceptions);

            }

        }

}