using System.Threading.Tasks;

using System.Collections.Concurrent;

using System;

using System.Threading;

public class Program

{

    public static async Task Main()

    {

        var service = new Service();

​

        // ИТЕРАЦИЯ 1

​

        var blocker1 = new Blocker();

​

        service.AddBlocker(blocker1);

​

        using var semaphore1 = new SemaphoreSlim(0, 1);

​

        Task.Run(async () =>

        {

            await Task.Delay(100).ConfigureAwait(false);

            await semaphore1.WaitAsync().ConfigureAwait(false);

            blocker1.Release();

            Console.WriteLine("Blocker 1 released.");

        });

​

        var serviceTask1 = Task.Run(async () =>

        {

            await service.WaitBlockersAsync().ConfigureAwait(false);

        });

​

        semaphore1.Release();

​

        await serviceTask1.ConfigureAwait(false);

​

        // ИТЕРАЦИЯ 2

​

        var blocker2 = new Blocker();

​

        service.AddBlocker(blocker2);

​

        using var semaphore2 = new SemaphoreSlim(0);

​

        Task.Run(async () =>

        {

            await Task.Delay(100).ConfigureAwait(false);

            await semaphore2.WaitAsync().ConfigureAwait(false);

            blocker2.Release();

            Console.WriteLine("Blocker 2 released.");

        });

​

        var serviceTask2 = Task.Run(async () =>

        {

            await service.WaitBlockersAsync().ConfigureAwait(false);

        });

​

        semaphore2.Release();

​

        await serviceTask2.ConfigureAwait(false);

        Console.WriteLine("ASSERT");

    }

    class Blocker

    {

        public event EventHandler Released;

        public void Release()

        {

            Released?.Invoke(this, EventArgs.Empty);

        }

    }

    class Service

    {

        private object _lockObject = new object();

        private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();

        private readonly ConcurrentDictionary<Blocker, byte> _commandBlockers = new ConcurrentDictionary<Blocker, byte>();

        public Task WaitBlockersAsync()

        {

          lock (_lockObject)

          {

            if (_tcs is null)

            {

                return Task.CompletedTask;

            }

​

            return _tcs.Task;

          }

        }

​

        public void AddBlocker(Blocker commandBlocker)

        {

          lock (_lockObject)

          {

            commandBlocker.Released += CommandBlocker_Release;

            _commandBlockers.TryAdd(commandBlocker, 0);

​

            if (_tcs is null)

            {

                _tcs = new TaskCompletionSource<bool>();

            }

          }

        }

​

        private void CommandBlocker_Release(object? sender, EventArgs e)

        {

          lock (_lockObject)

          {

              var blocker = (Blocker)sender;

              blocker.Released -= CommandBlocker_Release;

              _commandBlockers.TryRemove(blocker, out var _);

​

              if (_commandBlockers.IsEmpty && _tcs != null)

              {

                _tcs.SetResult(true);

                _tcs = null;

              }

          }

        }

    }

}