Async Messaging

[k-g-nolan]

Background

I think it would be great if we could add async versions of the standard messaging methods and interfaces.

Right now, messaging looks something like this:

public class MessageGenerator
{
    ...

    private void SendMessage(MessageType message)
    {
        WeakReferenceMessenger.Default.Send(message);
    }

    ...
} 

public class MessageReceiver: ObservableRecipient, IRecipient<MessageType>
{
    ...

    public void Receive(MessageType message)
    {
        ProcessMessage(message);
    }

    private void ProcessMessage(MessageType message) { ... }

    ...
}

However, I find that sometimes I want to perform I/O operations or more intense processing after receiving a message. It's natural to put this sort of work in an async method, but that makes the messaging implementation a little clunky. You either have to use Task.Run() to "fire and forget" the async operation, or use async void:

// This feels clunky because you don't really have any error handling options...
public void Receive(MessageType message) 
{
    _ = Task.Run(() => ProcessMessageAsync(message));
}

// ... And this feels clunky because it uses async void
public async void Receive(MessageType message)
{
    await ProcessMessageAsync(message);
}

Proposal

I propose the addition of a new interface: IAsyncRecipient<T>, and a new method on the WeakReferenceMessenger class; SendAsync().

Similar to the IRecipient interface, the IAsyncRecipient interface would define a single method:

public interface IAsyncRecipient<in TMessage> where TMessage : class
{
    Task ReceiveAsync(TMessage message)
}

Then, the above clunky code could be modified to be more natural:

public class MessageGenerator
{
    ...

    private Task SendMessageAsync(MessageType message)
    {
        await WeakReferenceMessenger.Default.SendAsync(message);
    }

    ...
} 

public class MessageReceiver: ObservableRecipient, IAsyncRecipient<MessageType>
{
    ...

    public async Task Receive(MessageType message)
    {
        await ProcessMessageAsync(message);
    }

    private Task ProcessMessageAsync(MessageType message) { ... }

    ...
}

In addition, it may be useful to consider other "nice to have" features related to async programming, like incorporating CancellationTokens.