using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace ConsoleApp1

{

    public class Program

    {

        private static readonly List<int> codes = new List<int>();

​

​

        public static void Main(string[] args)

        {

            for (int i = 0; i < 200; i++)

                codes.Add(i);

​

            var processor = new ConcurrentCalculationProcessor(codes);

            var data = Task.Run(async () => await processor.Execute()).GetAwaiter().GetResult();

​

        }

​

    }

​

    public class ConcurrentCalculationProcessor

    {

        private const int MAX_CONCURRENT_TASKS = 4;

        private readonly IEnumerable<int> _codes;

        private readonly List<Task<Dictionary<string, CalculationResult>>> _tasks;

        private readonly Dictionary<string, CalculationResult> _combinationsReal;

​

        public ConcurrentCalculationProcessor(IEnumerable<int> codes)

        {

            this._codes = codes;

            this._tasks = new List<Task<Dictionary<string, CalculationResult>>>();

            this._combinationsReal = new Dictionary<string, CalculationResult>();

        }

​

        private async Task<Dictionary<string, CalculationResult>> ProcessCombinations()

        {

            Dictionary<string, CalculationResult> combinations = new Dictionary<string, CalculationResult>();

            // do the processing

            for (int i = 0; i < 100; i++)

                combinations[i.ToString()] = new CalculationResult(new decimal[] { 1, 10, 15 }); // dummy data

                                                                                                 // add combination to combinations -> same logic as in single core implementation

            return await Task.FromResult(combinations);

        }

​

        public async Task<Dictionary<string, CalculationResult>> Execute()

        {

            ConcurrentBag<Dictionary<string, CalculationResult>> results = new ConcurrentBag<Dictionary<string, CalculationResult>>();

​

            for (int i = 0; i < this._codes.Count(); i++)

            {

                // start the task imediately

                var task = ProcessCombinations();

                this._tasks.Add(task);

                if (this._tasks.Count() >= MAX_CONCURRENT_TASKS)

                {

                    // if we have more than 4 tasks in progress (not completed yet), we start processing some of the completed tasks

                    // this will await any of the current tasks to complete, them process it (and any other task which may have been completed as well)...

                    await ProcessRealCombinations().ConfigureAwait(false);

                }

            }

​

            // wait until all the last tasks have been completed...

            while (this._tasks.Any())

                await ProcessRealCombinations().ConfigureAwait(false);

​

            return this._combinationsReal;

        }

​

        private async Task ProcessRealCombinations()

        {

            var completedTasks = this._tasks.Where(t => t.IsCompleted).ToArray();

            // completedTasks will have at least one task, but it may have more ;)

            foreach (var completedTask in completedTasks)

            {

                var processedCombinations = await completedTask.ConfigureAwait(false);

                foreach (var pair in processedCombinations)

                {

                    if (this._combinationsReal.ContainsKey(pair.Key))

                        this._combinationsReal[pair.Key].Update(pair.Value);

                    else

                        this._combinationsReal.Add(pair.Key, pair.Value);

                }

                this._tasks.Remove(completedTask);

            }

        }

​

    }

​

    public class CalculationResult

    {

        public int Count { get; set; }

        public decimal[] RunningTotals { get; set; }

​

        public CalculationResult(decimal[] profits)

        {

            this.Count = 1;

            this.RunningTotals = new decimal[12];

            profits.CopyTo(this.RunningTotals, 0);

        }

​

        public void Update(decimal[] newData)

        {

            this.Count++;

​

            // summ arrays

            for (int i = 0; i < 12; i++)

                this.RunningTotals[i] = this.RunningTotals[i] + newData[i];

        }

​

        public void Update(CalculationResult otherResult)

        {

            this.Count += otherResult.Count;

​

            // summ arrays

            for (int i = 0; i < 12; i++)

                this.RunningTotals[i] = this.RunningTotals[i] + otherResult.RunningTotals[i];

        }

    }

​

}

​