Do Multi delegate Async Actions Only work with Begin Invoke

Question

I'm trying to understand async actions and I'm a bit confused. Actions are just glorified Delegates. Given the Actions

Action act = null;
act += () => { Console.WriteLine("Sync"); };
act += async () =>  { await File.AppendAllLinesAsync("C:/Test.Txt", 
                                    new[] { "Async File Operation" }); 
                     };

How can we invoke this async seeing as one of the delegates is async and the other is not. I've seen some extension methods in other SO answers simplified for the example would look like so:

public static void InvokeAsync(this Action action, AsyncCallback ar, object userObject = null)
{
    var listeners = action.GetInvocationList();
    foreach (var t in listeners)
    {
        var handler = (Action)t;
        handler.BeginInvoke(ar, userObject);
    }
}

I'm concerned if this even works because it looks like it invokes your callback for each listener which doesn't make sense.

I've only been using async with the more friendly version async/await so I do not understand this syntax as much. (I'm assuming the callback would be everything after the await and the userObject is equivalent to the dreadful SyncronizationContext that causes deadlocks if when calling sync without ConfigureAwait(false), but that is just a guess)

This is syntax inconvenient so I would perfer to use async await syntax, since async/await is called using duck-typing. I've read a blog about using async with delegates which for the example

public static class DelegateExtensions
{
    public static TaskAwaiter GetAwaiter(this Action action)
    {
        Task task = new Task(action);
        task.Start();
        return task.GetAwaiter();
    }
}

This too concerns me for a few reason, this looks much like an anti pattern.
Isn't this just creating a task which will run my action synchronous on a seperate thread? I also don't see this run through the invocation list.

Are either of these methods proper for invoking run delegates asynchronously? Is there a way I can invoke an async delegate with the await syntax while still fully leveraging async? What is the proper way to invoke async delegates with multiple functions in the invocation list?

Answer 1

I think Eric Lippert's comment have clarified the situation more than I could ever. Overall, if you need to act on the return type of a method, you shouldn't use multicast delegates. If you still have to, at least use a Func<Task> signature, then you can iterate on each individual delegate using GetInvocationList, as explained here.

But would it be really impossible to work your way out of a multicast delegate with async void method?

It turns out that you can be notified of beginning and end of async void methods by using a custom synchronization context and overriding the OperationStarted and OperationCompleted methods. We can also override the Post method to set the synchronization context of child operations, to capture subsequent async void calls.

Piecing it together, you could come with something like:

class Program
{
    static async Task Main(string[] args)
    {
        Action act = null;
        act += () => { Console.WriteLine("Sync"); };
        act += async () =>
        {
            Callback();

            await Task.Delay(1000);

            Console.WriteLine("Async");
        };

        await AwaitAction(act);

        Console.WriteLine("Done");

        Console.ReadLine();
    }

    static async void Callback()
    {
        await Task.Delay(2000);

        Console.WriteLine("Async2");
    }

    static Task AwaitAction(Action action)
    {
        var delegates = action.GetInvocationList();

        var oldSynchronizationContext = SynchronizationContext.Current;

        var asyncVoidSynchronizationContext = new AsyncVoidSynchronizationContext();

        try
        {
            SynchronizationContext.SetSynchronizationContext(asyncVoidSynchronizationContext);

            var tasks = new Task[delegates.Length];

            for (int i = 0; i < delegates.Length; i++)
            {
                ((Action)delegates[i]).Invoke();
                tasks[i] = asyncVoidSynchronizationContext.GetTaskForLastOperation();
            }

            return Task.WhenAll(tasks);
        }
        finally
        {
            SynchronizationContext.SetSynchronizationContext(oldSynchronizationContext);
        }
    }
}

public class AsyncVoidSynchronizationContext : SynchronizationContext
{
    private TaskCompletionSource<object> _tcs;
    private Task _latestTask;

    private int _operationCount;

    public Task GetTaskForLastOperation()
    {
        if (_latestTask != null)
        {
            var task = _latestTask;
            _latestTask = null;
            return task;
        }

        return Task.CompletedTask;
    }

    public override void Post(SendOrPostCallback d, object state)
    {
        Task.Run(() =>
        {
            SynchronizationContext.SetSynchronizationContext(this);

            d(state);
        });
    }
  
    public override void OperationStarted()
    {
        if (Interlocked.Increment(ref _operationCount) == 1)
        {
            // First operation
            _tcs = new TaskCompletionSource<object>();
            _latestTask = _tcs.Task;
        }

        base.OperationStarted();
    }

    public override void OperationCompleted()
    {
        if (Interlocked.Decrement(ref _operationCount) == 0)
        {
            // Last operation
            _tcs.TrySetResult(null);
        }

        base.OperationCompleted();
    }
}

The output would be:

Sync

Async

Async2

Done

Of course, this code is provided just for recreational purpose. There's plenty of limitations, such as the fact the fact that it wouldn't work as-is if you're already using a synchronization context (such as the WPF one). I'm also certain that it has a few subtle bugs and concurrency issues here and there.