Why Do I Need To Make This Method Async?

Question

I've got code very similar to this (I've simplified the code a bit to demonstrate the essence of the behavior I'm trying to figure out).

public async System.Threading.Tasks.Task<bool> IsNumberOdd(int numToTest)
{
    if (numToTest % 2 == 0)
    {
        return false;
    }
    else
    {
        return true;
    }
}

If I leave off the async keyword, I get a complaint about not being able to cast a bool to a Task<bool>. I'm assuming there's some syntactic sugar involved here. Looking at the IL (I'm not super familiar with IL) it seems as if the async keyword is causing the task to be run and then the return value is the result of the task. Am I understanding this correctly?

By the way, if this is a dupe or if there's some blog posting that discusses this, feel free to point me to it and close this up. I'm not trying to pad my rep; I'm trying to understand what's going on with this code.

EDIT:

---

For all those who were asking "why is this method async?"--because I was trying to build a small and simple code example to demonstrate the question. I should have also added an example of the calling code but I was trying to keep the code as small and simple as I could.

Answer 1

I'm assuming there's some syntactic sugar involved here

Not exactly "syntactic sugar". The compiler is generating a state-machine as the method was marked as async. That is why you can return a Task<bool> without explicitly creating a Task for the return value.

If I leave off the async keyword, I get a complaint about not being able to cast a bool to a Task<bool>.

The async modifier is what triggers the compiler to create the state machine. If you remove it, you'll need to create the Task yourself. If for any reason you want to create a Task<T> but you're actually running synchronously, Task.FromResult is your friend.

I see no reason why this method is marked async.

Answer 2

it seems as if the async keyword is causing the task to be run and then the return value is the result of the task

Correct.

There is nothing in this method that would benefit from it being async. However:

If I leave off the async keyword, I get a complaint about not being able to cast a bool to a Task<bool>

Would be happening in the caller. Without seeing that code one can only comment generally that you can either:

• Change the caller to not assume it is getting a waitable return.
• Change the function to return bool, but on the caller use Task.FromResult(IsNumberOdd(value)).

Answer 3

It's not about the async. Its about the Task.

your returning a bool and the return value of your function is Task

     public Task<bool> DoSomething()
     { 
         return false;
     }

will also not compile. if your not doing any thing asynchronous you shouldn't return a Task.

If you need to run something asynchronously , here are a few options which i hope will make the usage of async/await clearer.

public class Sample
{
    public async void RunSample() 
    {
        // return a task. later obtain a result if some fashion 
        Task<bool> task = DoSomethingAsync();
        bool res1 = task.Result;

        // await a task which is created for you by re-wrapping the result.
        bool res2 = await AwaitSomethingAsync();

        // await a task which is created for you by rewrapping the result due to await.
        bool res3 = await DoSomethingAsync2();

        // await a task.
        bool res4 = await DoSomethingAsync();     
    }


    public async Task<bool> DoSomethingAsync2()
    {
        return false;
    }

    public Task<bool> DoSomethingAsync()
    {
        return Task<bool>.Run(() => { return false; });
    }

    public async Task<bool> AwaitSomethingAsync()
    {
        bool res = await Task<bool>.Run(() => { return false; });
        return res; // re-wraps it in a Task
    }

}