using System;

using System.Threading;

using System.Threading.Tasks;

​

class Program

{

    async static Task Main()

    {

        var bugged = true;

​

        if (bugged)

            await Use();

        else

            Use();

​

        while (true) Console.ReadKey();

    }

​

    public static async Task Use()

    {

        var coordinator = new TaskCoordinator();

​

        coordinator.Register(Task1);

        async Task Task1(TaskCoordinator.Handle handle)

        {

            await Task.Delay(200);

​

            throw new NotImplementedException();

​

            Program.Print("Task 1 Finished");

        }

​

        coordinator.Register(Task2);

        async Task Task2(TaskCoordinator.Handle handle)

        {

            await Task.Delay(400);

            handle.ThrowIfCancellationRequested();

​

            Program.Print("Task 2 Finished");

        }

​

        coordinator.Register(Task3);

        async Task Task3(TaskCoordinator.Handle handle)

        {

            await Task.Delay(400);

            handle.ThrowIfCancellationRequested();

​

            Program.Print("Task 3 Finished");

        }

​

        try

        {

            await coordinator.Await();

        }

        catch (Exception ex)

        {

            Program.Print(ex);

            return;

        }

​

        Program.Print("Done");

    }

​

    public static void Print(object target) => Console.WriteLine(target);

}

​

class TaskCoordinator

{

    CancellationTokenSource CancellationSource;

    public CancellationToken CancellationToken => CancellationSource.Token;

​

    TaskCompletionSource<bool> StartSource;

    TaskCompletionSource<bool> ProcessingSource;

​

    volatile int HandleCount;

    public Handle CreateHandle()

    {

        Interlocked.Increment(ref HandleCount);

​

        return new Handle(this);

    }

​

    public async Task Await()

    {

        StartSource.SetResult(true);

​

        await ProcessingSource.Task;

    }

​

    void CompleteHandle()

    {

        if (Interlocked.Decrement(ref HandleCount) is not 0)

            return;

​

        ProcessingSource.TrySetResult(true);

    }

    void FailHandle(Exception exception)

    {

        try

        {

            Program.Print("Previous Line");

​

            var output = ProcessingSource.TrySetException(exception);

​

            Program.Print("Next Line");

​

            if (output is false)

                return;

​

            CancellationSource.Cancel();

        }

        catch (Exception)

        {

            Program.Print("Catch Exception");

        }

        finally

        {

            Program.Print("Finally Block");

        }

    }

​

    public void Register(Func<Handle, Task> function)

    {

        var handle = CreateHandle();

        var task = function(handle);

​

        Register(task);

    }

    public async void Register(Task task)

    {

        try

        {

            await StartSource.Task;

​

            await task;

​

            CompleteHandle();

        }

        catch (OperationCanceledException) when (CancellationToken.IsCancellationRequested)

        {

            //Do Nothing

        }

        catch (Exception ex)

        {

            FailHandle(ex);

        }

    }

​

    public TaskCoordinator()

    {

        CancellationSource = new CancellationTokenSource();

​

        StartSource = new();

        ProcessingSource = new();

    }

​

    public struct Handle

    {

        readonly TaskCoordinator Coordinator;

        public CancellationToken CancellationToken => Coordinator.CancellationToken;

​

        public bool IsCancellationRequested => CancellationToken.IsCancellationRequested;

        public void ThrowIfCancellationRequested() => CancellationToken.ThrowIfCancellationRequested();

​

        public void Fail()

        {

            var exception = new Exception($"Handle Failed");

​

            Fail(exception);

        }

        public void Fail(Exception exception)

        {

            Coordinator.FailHandle(exception);

        }

​

        public Handle(TaskCoordinator Coordinator)

        {

            this.Coordinator = Coordinator;

        }

    }

}