How do I await events in C#?

by

Personally, I think that having async event handlers may not be the best design choice, not the least of which reason being the very problem you’re having. With synchronous handlers, it’s trivial to know when they complete.

That said, if for some reason you must or at least are strongly compelled to stick with this design, you can do it in an await-friendly way.

Your idea to register handlers and await them is a good one. However, I would suggest sticking with the existing event paradigm, as that will keep the expressiveness of events in your code. The main thing is that you have to deviate from the standard EventHandler-based delegate type, and use a delegate type that returns a Task so that you can await the handlers.

Here’s a simple example illustrating what I mean:

class A
{
    public event Func<object, EventArgs, Task> Shutdown;

    public async Task OnShutdown()
    {
        Func<object, EventArgs, Task> handler = Shutdown;

        if (handler == null)
        {
            return;
        }

        Delegate[] invocationList = handler.GetInvocationList();
        Task[] handlerTasks = new Task[invocationList.Length];

        for (int i = 0; i < invocationList.Length; i++)
        {
            handlerTasks[i] = ((Func<object, EventArgs, Task>)invocationList[i])(this, EventArgs.Empty);
        }

        await Task.WhenAll(handlerTasks);
    }
}

The OnShutdown() method, after doing the standard “get local copy of the event delegate instance”, first invokes all of the handlers, and then awaits all of the returned Tasks (having saved them to a local array as the handlers are invoked).

Here’s a short console program illustrating the use:

class Program
{
    static void Main(string[] args)
    {
        A a = new A();

        a.Shutdown += Handler1;
        a.Shutdown += Handler2;
        a.Shutdown += Handler3;

        a.OnShutdown().Wait();
    }

    static async Task Handler1(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #1");
        await Task.Delay(1000);
        Console.WriteLine("Done with shutdown handler #1");
    }

    static async Task Handler2(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #2");
        await Task.Delay(5000);
        Console.WriteLine("Done with shutdown handler #2");
    }

    static async Task Handler3(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #3");
        await Task.Delay(2000);
        Console.WriteLine("Done with shutdown handler #3");
    }
}

Having gone through this example, I now find myself wondering if there couldn’t have been a way for C# to abstract this a bit. Maybe it would have been too complicated a change, but the current mix of the old-style void-returning event handlers and the new async/await feature does seem a bit awkward. The above works (and works well, IMHO), but it would have been nice to have better CLR and/or language support for the scenario (i.e. be able to await a multicast delegate and have the C# compiler turn that into a call to WhenAll()).

More Related Contents:

  1. Should I avoid ‘async void’ event handlers?
  2. How to remove all event handlers from an event
  3. Running multiple async tasks and waiting for them all to complete
  4. Difference between events and delegates and its respective applications [closed]
  5. Checking for null before event dispatching… thread safe?
  6. Why does this async action hang when I try and access the Result property of my Task?
  7. How to limit the Maximum number of parallel tasks in c#
  8. .NET Asynchronous stream read/write
  9. Is there some way to handle async/await behind an ASMX service?
  10. Adding and Removing Anonymous Event Handler
  11. Benefits of using async and await keywords
  12. Do asynchronous operations in ASP.NET MVC use a thread from ThreadPool on .NET 4
  13. Using Moq to mock an asynchronous method for a unit test
  14. Event handlers not thread safe? [duplicate]
  15. How to correctly unregister an event handler
  16. Why use async and return await, when you can return Task directly?
  17. async await return Task
  18. Executing tasks in parallel
  19. What is the difference between using and await using? And how can I decide which one to use?
  20. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  21. A pattern for self-cancelling and restarting task
  22. How can I capture the value of an outer variable inside a lambda expression?
  23. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  24. “Asynchronous operations are not allowed in this context”
  25. What is the difference between .Wait() vs .GetAwaiter().GetResult()?
  26. Why use async requests instead of using a larger threadpool?
  27. Is it ok to await the same task from multiple threads – is await thread safe?
  28. Await and SynchronizationContext in a managed component hosted by an unmanaged app
  29. C# Async Serial Port Read
  30. How to implement Task.WhenAny() with a predicate

Leave a Comment