Use async without await with a function that holds another function that returns void

Question

So I have this WrapperFunction that tries to make a FunctionReturningVoid to be called asynchronously:

    public async Task WrapperFunction()
    {
        this.FunctionReturningVoid("aParameter");
    }

This is the function that returns nothing. In some parts of the code (not detailed here) it is called SYNChronously but in the CallerFunction() we want it to be run ASYNChronously.

    public void FunctionReturningVoid(string myString)
    {
        Console.Write(myString);
    }

This is the function that has the async implemented and needs to have WrapperFunction do its things without blocking otherStuff().

    public async Task CallerFunction()
    {
        await WrapperFunction():
        int regular = otherStuff();
        ...
    }

The IDE is warning me that WrapperFunction is not using await:

This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.

Question: How to use async without using await in WrapperFunction? If I use await it tells me that cannot await void.

Ok. Those are some facts. But what is your question, exactly? — ADyson, Nov 20 '19 at 14:52
`WrapperFunction` just needs to `return Task.Run(() => this.FunctionReturningVoid("aParameter"));` — Matthew Watson, Nov 20 '19 at 14:53
A second option is to remove the `async` keyword from `WrapperFunction` (i.e., `public Task WrapperFunction()`) and then add `return Task.CompletedTask` at the end. — howcheng, Nov 20 '19 at 17:33

Gabriel Luci · Accepted Answer · 2019-11-20T15:44:12.827

It's important to distinguish asynchronous from parallel.

Asynchronous means not blocking the current thread while you're waiting for something to happen. This lets the current thread go do something else while waiting.

Parallel means doing more than one thing at the same time. This requires separate threads for each task.

You cannot call FunctionReturningVoid asynchronously because it is not an asynchronous method. In your example, Console.WriteLine() is written in a way that will block the thread until it completes. You can't change that. But I understand that's just your example for this question. If your actual method is doing some kind of I/O operation, like a network request or writing a file, you could rewrite it to use asynchronous methods. But if it's doing CPU-heavy work, or you just can't rewrite it, then you're stuck with it being synchronous - it will block the current thread while it runs.

However, you can run FunctionReturningVoid in parallel (on another thread) and wait for it asynchronously (so it doesn't block the current thread). This would be wise if this is a desktop application - you don't want to lock up your UI while it runs.

To do that, you can use Task.Run, which will start running code on another thread and return a Task that you can use to know when it completes. That means your WrapperFunction would look like this:

public Task WrapperFunction()
{
    return Task.Run(() => this.FunctionReturningVoid("aParameter"));
}

Side point: Notice I removed the async keyword. It's not necessary since you can just pass the Task to the calling method. There is more information about this here.

Microsoft has some well-written articles about Asynchronous programming with async and await that are worth the read.

Use async without await with a function that holds another function that returns void

1 Answers1