Problem with async/await pattern -- in C# and JavaScript -- how to return sync value

Question

In old-style await'less NodeJS, when you call a function that had an asynchronous aspect, you'd pass in the well-known callback which gets called when the asynchronous portion is done. This didn't pollute the return value of the function whereas the function can still return something meaningful to the caller synchronously.

The problem with the async/await pattern now is that to use it, you have to decide if a function is synchronous or asynchronous. This means that if I have an existing function that's synchronous, and has a return value that will remain synchronously calculated and thus returned when the function returns, and I want to add an asynchronous component to it, previously I would add a callback, and change the callers. But now I have to make the return value the asynchronous value and the original return value --- find another way. What would that be?

Would you use an 'out' parameter in C#? That's not a best-practice. Would you pass in an object whose state you modify to return the sync value?

The current trend is return a tuple, and object with multiple values. But can one of those values by synchronous and the other asynchronous?

Answer 1

Why can't you return an already completed task?

C#: return Task.FromResult(...);

JavaScript: return Promise.resolve(...);

In fact, C# recently added ValueTask<T> to avoid allocations for this scenario where a value is available immediately.

Answer 2

The current trend is return a tuple, and object with multiple values. But can one of those values by synchronous and the other asynchronous?

surely you can return it. Tuple<Foo, Task<Bar>>. You can create it like this:

// this is a function starting a task producing Bar
Task<Bar> GetBarAsync() {
    ...
}

...

Tuple<Foo, Task<Bar>> Baz()
{
    return Tuple.Create(
        new Foo(),
        GetBarAsync());
}

However, as this is SE, I would add that I don't clearly undestand why would you need such function. It clearly mixes concerns to me. Asynchronous function does not mean to be doing anything at the moment of call. It does something, in fact, but it does not matter in a typical scenario.

Answer 3

Why would you want this at all? Sticking to your example with the Book and the Footnotes, where one is fetched synchronously and the other one is fetched asynchronously, it should really be two methods (or at least two method calls), instead of one, since fetching the Book synchrnously and fetching the Book with footnotes asynchronously are two slightly different things.

From your comment to the other answer:

But for a client that does care, he wants to wait for the task to complete. How to return the task to the caller as well as the book.

You could add a parameter to specify what you'd like to fetch. Only the metadata (for the sake of your question we'd assume that the metadata would be returned quickly) or extended data (which won't be returned that quickly)

public Book FetchBook(FetchBookOptions options);
public Task<Book> FetchBookAsync(FetchBookOptions options);

[Flags]
public enum FetchBookOptions
{
    None,
    Metadata = 1,
    Content = 2,
    Footnotes = 4,
    All = Metadata | Content | Footnotes
}

The client that cares for the metadata, the footnotes and the content, but needs to stay responsive, may call

var book = await bookRepository.FetchBookAsync(FetchBookOptions.All);

The client that dows not make use of async/await, but needs all data may call

 var book = await bookRepository.FetchBookAsync(FetchBookOptions.All);

and the client that only needs the metadata, which is known to be provided "immediately" may either call

var book = await bookRepository.FetchBookAsync(FetchBookOptions.Metadata);

or

var book = await bookRepository.FetchBookAsync(FetchBookOptions.Metadata);

Eventually you coud do somthing like this

private async void Button_OnClick()
{
    this.SetBooks(await bookRepository.FetchBookAsync(FetchBookOptions.Metadata));
    this.UpdateBooksFootnotes(await bookRepository.FetchBooksAsync(FetchBookOptions.All));
}

This achieves exactly what you want, setting the original books immediately - given that FetchBookOptions.Metadata returns immediately, or at least very quickly - and as soon as the footnotes have been fetched, you can update them.

Answer 4

The current trend is return a tuple, and object with multiple values. But can one of those values by synchronous and the other asynchronous?

Yes, quite simply Tuple<Foo, Task<Bar>>.

But you maybe don't want that. Instead, return both asynchronously.

async Task<Tuple<Foo, Bar>> getFooBarAsync()
{
    var bar = getBarAsync();
    var foo = getFoo();
    return new Tuple<Foo, Bar>(foo, await bar);
}