How should an async callback in a WinRT object be implemented?

Question

So far I could make a delegate type, for example:

// Can't use Task in WinRT interface and TypedEventHandler doesn't work with async await
public delegate IAsyncOperation<string> AsyncEventHandler(object sender, object args);

And then expose in WinRT object like so:

public AsyncEventHandler OnMyEvent { get; set; }

In the WinRT object I would call it like this:

if (OnMyEvent != null)
{
    var result = await OnMyEvent.Invoke(this, someArgs);
    // Do something with the result...
}

And the client code consuming the WinRT object could do this:

instanceOfWinRTObject.OnMyEvent = OnCalledBackFromWinRT;

But because the delegate returns an IAsyncOperation we need to do some wrapping:

private async Task<string> OnCalledBackFromWinRTAsync(object sender,
        object args)
{
    return await GetSomeStringAsync(args);
}

private IAsyncOperation<string> OnCalledBackFromWinRT(object sender, object args)
{
    return OnCalledBackFromWinRTAsync(sender, args).AsAsyncOperation();
}

It just feels like there must be a cleaner way to achieve this.

If you want an event where the handler can be async, the typical pattern is to use a deferral on the event args (eg see the suspending event) — Peter Torr - MSFT, Jul 03 '18 at 07:50
Thanks for the suggestion. Do you agree with my example code below? — Johnny Haddock, Jul 04 '18 at 10:17

score 0 · Accepted Answer · answered Jul 04 '18 at 10:17

Here is an alternative prompted by Peter Torr's comment.

// Custom event args class
public sealed class MyEventArgs
{
    public string Result;
    public Deferral Deferral;
}

// Declare the event handler on the WinRT component
public event TypedEventHandler<object, MyEventArgs> OnSuspendingEvent;

Then in the WinRT component you could invoke the event like this:

if (OnSuspendingEvent != null)
{
    var tcs = new TaskCompletionSource();
    using (var deferral = new Deferral(() => tcs.SetResult(true)))
    {
        var myArgs = MyEventArgs();
        myArgs.Deferral = deferral;
        OnSuspendUnloading.Invoke(this, myArgs);
        await tcs.Task;
        DoSomethingWithResult(args.Result);
    }
}

And finally in the client code add a handler like so:

instanceOfWinRTObject.OnSuspendingEvent += async (sender, args) =>
{
    var deferral = args.Deferral;
    try
    {
        // Client does some async work with a result
        args.Result = await GetSomeStringAsync(args);
    }
    finally
    {
        deferral.Complete();
    }
}

How should an async callback in a WinRT object be implemented?

1 Answers1