// -----

// This code is discussed in more detail at this blog post:

// https://www.devleader.ca/2023/01/27/async-void-how-to-tame-the-asynchronous-nightmare/

// -----

// History:

// 2022-01-29

// - Updated code to support this race condition exception:

//   Unhandled exception. System.InvalidOperationException: An attempt was made to transition a task to a final state when it had already completed.

using System;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.ExceptionServices;

​

var someEventRaisingObject = new SomeEventRaisingObject();

​

// notice the async void. BEHOLD!!

someEventRaisingObject.TheEvent += async (s, e) =>

{

    Console.WriteLine("Entering the event handler...");

    await TaskThatIsReallyImportantAsync();

    Console.WriteLine("Exiting the event handler...");

};

​

try

{

    // forcefully fire our event!

    await someEventRaisingObject.RaiseEventAsync();

}

catch (Exception ex)

{

    Console.WriteLine($"Caught an exception in our handler: {ex.Message}");

}

​

// just block so we can wait for async operations to complete

Console.WriteLine("Press Enter to exit");

Console.ReadLine();

​

​

async Task TaskThatIsReallyImportantAsync()

{

    // switch between these two lines (comment one or the other out) to play with the behavior

    throw new Exception("This is an expected exception");

    //await Task.Run(() => Console.WriteLine("Look at us writing to the console from a task!"));

}

class SomeEventRaisingObject

{

    // you could in theory have your own event args here

    public event EventHandler<EventArgs> TheEvent;

    public Task RaiseEventAsync()

    {

        // the old way (if you toggle this way with the exception throwing, it will not hit our handler!)

        //TheEvent?.Invoke(this, EventArgs.Empty);

        //return Task.CompletedTask;

        // the new way (if you toggle this way with the exception throwing, it WILL hit our handler!)

        return InvokeAsync(TheEvent, true, true, this, EventArgs.Empty);

    }

    private async Task InvokeAsync(

            MulticastDelegate theDelegate,

            bool forceOrdering,

            bool stopOnFirstError,

            params object[] args)

        {

            if (theDelegate is null)

            {

                return;

            }

​

            var taskCompletionSource = new TaskCompletionSource<bool>();

​

            // this is used to try and ensure we do not try and set more

            // information on the TaskCompletionSource after it is complete

            // due to some out-of-ordering issues

            bool taskCompletionSourceCompleted = false;

​

            var delegates = theDelegate.GetInvocationList();

            var countOfDelegates = delegates.Length;

​

            // keep track of exceptions along the way and a separate collection

            // for exceptions we have assigned to the TCS

            var assignedExceptions = new List<Exception>();

            var trackedExceptions = new ConcurrentQueue<Exception>();

​

            foreach (var @delegate in theDelegate.GetInvocationList())

            {

                var async = @delegate.Method

                    .GetCustomAttributes(typeof(AsyncStateMachineAttribute), false)

                    .Any();

​

                bool waitFlag = false;

                var completed = new Action(() =>

                {

                    if (Interlocked.Decrement(ref countOfDelegates) == 0)

                    {

                        lock (taskCompletionSource)

                        {

                            if (taskCompletionSourceCompleted)

                            {

                                return;

                            }

​

                            assignedExceptions.AddRange(trackedExceptions);

​

                            if (!trackedExceptions.Any())

                            {

                                taskCompletionSource.SetResult(true);

                            }

                            else if (trackedExceptions.Count == 1)

                            {

                                taskCompletionSource.SetException(assignedExceptions[0]);

                            }

                            else

                            {

                                taskCompletionSource.SetException(new AggregateException(assignedExceptions));

                            }

​

                            taskCompletionSourceCompleted = true;

                        }

                    }

​

                    waitFlag = true;

                });

                var failed = new Action<Exception>(e =>

                {

                    trackedExceptions.Enqueue(e);

                });

​

                if (async)

                {

                    var context = new EventHandlerSynchronizationContext(completed, failed);

                    SynchronizationContext.SetSynchronizationContext(context);

                }

​

                try

                {

                    @delegate.DynamicInvoke(args);

                }

                catch (TargetParameterCountException e)

                {

                    throw;

                }

                catch (TargetInvocationException e) when (e.InnerException != null)

                {

                    // When exception occured inside Delegate.Invoke method all exceptions are wrapped in

                    // TargetInvocationException.

                    failed(e.InnerException);

                }

                catch (Exception e)

                {

                    failed(e);

                }

​

                if (!async)

                {

                    completed();

                }

​

                while (forceOrdering && !waitFlag)

                {

                    await Task.Yield();

                }

​

                if (stopOnFirstError && trackedExceptions.Any() && !taskCompletionSourceCompleted)

                {

                    lock (taskCompletionSource)

                    {

                        if (!taskCompletionSourceCompleted && !assignedExceptions.Any())

                        {

                            assignedExceptions.AddRange(trackedExceptions);

                            if (trackedExceptions.Count == 1)

                            {

                                taskCompletionSource.SetException(assignedExceptions[0]);

                            }

                            else

                            {

                                taskCompletionSource.SetException(new AggregateException(assignedExceptions));

                            }

​

                            taskCompletionSourceCompleted = true;

                        }

                    }

​

                    break;

                }

            }

​

            await taskCompletionSource.Task;

        }

​

        private class EventHandlerSynchronizationContext : SynchronizationContext

        {

            private readonly Action _completed;

            private readonly Action<Exception> _failed;

​

            public EventHandlerSynchronizationContext(

                Action completed,

                Action<Exception> failed)

            {

                _completed = completed;

                _failed = failed;

            }

​

            public override SynchronizationContext CreateCopy()

            {

                return new EventHandlerSynchronizationContext(

                    _completed,

                    _failed);

            }

​

            public override void Post(SendOrPostCallback d, object state)

            {

                if (state is ExceptionDispatchInfo edi)

                {

                    _failed(edi.SourceException);

                }

                else

                {

                    base.Post(d, state);

                }

            }

​

            public override void Send(SendOrPostCallback d, object state)

            {

                if (state is ExceptionDispatchInfo edi)

                {

                    _failed(edi.SourceException);

                }

                else

                {

                    base.Send(d, state);

                }

            }

​

            public override void OperationCompleted() => _completed();

        }

}