Why does an "async void" method run synchronously?

Question

Here Eric Lippert says:

A void returning async method cannot be awaited; it is a "fire and forget" method. It does work asynchronously...

It does work asynchronously right?

To test that, I made a windows form application and handled one arbitrary event. Inside handler, I started a heavy computation. Clearly, it blocks the UI to respond:

this.KeyPress += Form1_KeyPressed;
....
private async void Form1_KeyPressed(object sender, EventArgs e)
{
   for(int i=0; i<int.max; i++)
      ;
}

What am I missing in Eric's answer?

Answer 1

What am I missing in Eric's answer?

I meant that it works like any other asynchronous method. When you await something in an asynchronous method the remainder of the method is signed up as the continuation of the awaited thing. That is true whether the asynchronous method is void or not.

In your example your code works exactly like an asynchronous method that returns a task. Try changing your method to return a task, and you'll see it behaves exactly the same.

Remember, "async" does not mean "I run concurrently on another thread". It means "the method may return before its action is completed". The points at which it may return before its action is completed are marked with "await". You haven't marked anything with "await".

I suspect you believe the myth that asynchrony requires concurrency. Again: asynchrony simply means that a method can return before its work is done. You start cooking some eggs, the doorbell rings, you go get the package off the porch, you finish cooking the eggs, you open the package. The "cook eggs" and "fetch the mail" jobs are not concurrent -- you never did them at the same time. They are asynchronous.

Answer 2

All the async keyword does is allow you to await an asynchronous operation in your method (and wraps the result in a task).

Every async method runs synchronously until the first await is reached. If you don't await anything then this method (whether it returns a task or doesn't) will run synchronously.

If your method is synchronous you usually don't need to use async await at all. But if you want to offload a CPU intensive operation to a different thread so the UI thread wouldn't be blocked for a long time you can use Task.Run:

await Task.Run(() => CPUIntensiveMethod());

Answer 3

Only assigning method with async don't make it to call asynchronously.For asynchronously calling it need a method invokation with the await keyword in it's body.

And about this:

A void returning async method cannot be awaited; it is a "fire and forget" method. It does work asynchronously...

This means that you can not await THIS method inside another method like this.

await Form1_KeyPressed(this, EventArgs.Empty)

For your code to work you need a method with await keyword like:

private async void Form1_KeyPressed(object sender, EventArgs e)
{
   for(int i=0; i<int.max; i++)
      ;

   // In the body some code like this

   await YourMethod();

}

Updated version

The “Async” Keyword

What does the “async” keyword do when applied to a method?

When you mark a method with the “async” keyword, you’re really telling the compiler two things:

1. You’re telling the compiler that you want to be able to use the “await” keyword inside the method (you can use the await keyword if and only if the method or lambda it’s in is marked as async). In doing so, you’re telling the compiler to compile the method using a state machine, such that the method will be able to suspend and then resume asynchronously at await points.
2. You’re telling the compiler to “lift” the result of the method or any exceptions that may occur into the return type. For a method that returns Task or Task, this means that any returned value or exception that goes unhandled within the method is stored into the result task. For a method that returns void, this means that any exceptions are propagated to the caller’s context via whatever “SynchronizationContext” was current at the time of the method’s initial invocation.

Does using the “async” keyword on a method force all invocations of that method to be asynchronous?

No. When you invoke a method marked as “async”, it begins running synchronously on the curren thread. So, if you have a synchronous method that returns void and all you do to change it is mark it as “async”, invocations of that method will still run synchronously. This is true regardless of whether you leave the return type as “void” or change it to “Task”. Similarly, if you have a synchronous method that returns some TResult, and all you do is mark it as “async” and change the return type to be “Task”, invocations of that method will still run synchronously.

Marking a method as “async” does not affect whether the method runs to completion synchronously or asynchronously. Rather, it enables the method to be split into multiple pieces, some of which may run asynchronously, such that the method may complete asynchronously. The boundaries of these pieces can occur only where you explicitly code one using the “await” keyword, so if “await” isn’t used at all in a method’s code, there will only be one piece, and since that piece will start running synchronously, it (and the whole method with it) will complete synchronously.

For more see here:

http://blogs.msdn.com/b/pfxteam/archive/2012/04/12/async-await-faq.aspx

Answer 4

Async/await allow you to create code that can run asynchronously. It can even run in parallel (which is orthogonal to asynchrony). However, whether it does run parallel or not depends on how your task is scheduled.

When your code is called from a UI or ASP.NET context (more specifically, from the main thread in a context with UI control from these frameworks, since most controls can only be accessed on the thread that owns them), it is not scheduled to a background thread by default. You will still see that the execution of your code will wait for the Task to complete before continuing, but because the Task is scheduled to the same (main) thread, it will block any other actions on that thread (e.g. handling UI events).

If you know that your code is safe to execute in a background thread (again, this is usually because you know you are not accessing any control properties that are thread affine), you can overwrite the scheduling behavior with ConfigureAwait:

await DoWorkAsync().ConfigureAwait(false);

See also: Async/Await - Best Practices in Asynchronous Programming

Answer 5

Async is just a declaration that you might use asynchronous method. If you'll create a Task like

private async Task<int> callMe()
{
   int i;
   for(i = 0; i<int.max; i++)
      ;
   return i;
} 

you can run your code with line await callMe(); inside your KeyPressed event. Of course you don't have to return any value but it's just a practical example.

Answer 6

Just because you declare a method async doesnt make it automatically running in another thread.
You have to start one yourself with Task.Run().

So in your case this would be:

private async void Fomr1_KeyPressed(object sender, EventArgs e)
{
   await Task.Run(() => {
       for(int i=0; i<int.max; i++);
   });
}

Some good starting points for async/await:
Asynchronous Programming with Async and Await
Parallel Programming with .NET
Task Schedulers

Answer 7

I found this explanation from Filip Ekberg very enlightening:

Now it's important to remember that everything after the await keyword is executed in a continuation. The difference between using await and ContinueWith is that the continuation is in fact on the caller thread which in this case is the UI thread.

So:

private async void Form1_KeyPressed(object sender, EventArgs e)
{
   // ----------------------> Surely, on UI thread
   await Something(); ------> (May be) on new thread
   // ----------------------> Surely, on UI thread
   for(int i=0; i<int.max; i++)
      ;
}