using System;

using System.Collections.Generic;

using System.Threading;

using System.Threading.Tasks;

​

// https://stackoverflow.com/questions/75112527/how-can-i-use-parallel-tasks-and-make-them-not-waiting-each-other

public class Program

{

    public static void Main()

    {

        const int maximumConcurrency = 2;

        const int maximumParallelism = 1;

        Dictionary<string, (Task, CancellationTokenSource)> commandos = new();

        SemaphoreSlim semaphore = new(maximumConcurrency, maximumConcurrency);

        TaskScheduler scheduler = new ConcurrentExclusiveSchedulerPair(

            TaskScheduler.Default, maximumParallelism).ConcurrentScheduler;

​

        StartCommando("Task A");

        StartCommando("Task B");

        StartCommando("Task C");

​

        Thread.Sleep(500);

​

        StopCommando("Task A");

        StartCommando("Task D");

​

        Thread.Sleep(1000);

​

        Print($"Removing all commandos");

        try { DisposeAllCommandos().GetAwaiter().GetResult(); } catch (OperationCanceledException) { }

        Print($"Finished");

​

        void StartCommando(string commando)

        {

            Task existingTask = null;

            CancellationTokenSource existingCts = null;

            if (commandos.TryGetValue(commando, out var entry))

            {

                (existingTask, existingCts) = entry;

                existingCts.Cancel();

            }

            CancellationTokenSource cts = new();

            CancellationToken token = cts.Token;

            Task task = Task.Factory.StartNew(async () =>

            {

                if (existingTask is not null) try { await existingTask; } catch { }

                while (true)

                {

                    await semaphore.WaitAsync(token);

                    try

                    {

                        await MyFunction(commando, token);

                    }

                    finally { semaphore.Release(); }

                }

            }, token, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap();

            commandos[commando] = (task, cts);

            existingCts?.Dispose();

        }

​

        void StopCommando(string commando)

        {

            if (commandos.TryGetValue(commando, out var entry))

            {

                (_, CancellationTokenSource cts) = entry;

                cts.Cancel();

            }

        }

​

        Task DisposeAllCommandos()

        {

            List<Task> tasks = new(commandos.Count);

            foreach (var (commando, entry) in commandos)

            {

                (Task task, CancellationTokenSource cts) = entry;

                cts.Cancel();

                commandos.Remove(commando);

                cts.Dispose();

                tasks.Add(task);

            }

            return Task.WhenAll(tasks);

        }

​

        async Task MyFunction(string commando, CancellationToken token)

        {

            Print($"Starting {commando} iteration");

            await Task.Delay(200, token);

            Print($"Finishing {commando} iteration");

        }

    }

​

    private static void Print(object value)

    {

        Console.WriteLine($@"{DateTime.Now:HH:mm:ss.fff} [{Thread.CurrentThread

            .ManagedThreadId}] > {value}");

    }

}

​