How and when to use async and await

Question

One of the key benefits of async and await, in my opinion, is that they make code easier to write and comprehend; nevertheless, is utilising them equivalent to creating background threads to do long-running logic?

I'm currently putting the most basic example to the test. Inline comments have been added. Could you please explain it to me?

// I don't understand why this method must be marked as `async`.
private async void button1_Click(object sender, EventArgs e)
{
    Task<int> access = DoSomethingAsync();
    // task independent stuff here

    // this line is reached after the 5 seconds sleep from 
    // DoSomethingAsync() method. Shouldn't it be reached immediately? 
    int a = 1; 

    // from my understanding the waiting should be done here.
    int x = await access; 
}

async Task<int> DoSomethingAsync()
{
    // is this executed on a background thread?
    System.Threading.Thread.Sleep(5000);
    return 1;
}

Answer 1

The compiler creates a state machine in the background when async and await are used.

I'll try to illustrate some of the high-level details by using the following example:

public async Task MyMethodAsync()
{
    Task<int> longRunningTask = LongRunningOperationAsync();
    // independent work which doesn't need the result of LongRunningOperationAsync can be done here

    //and now we call await on the task 
    int result = await longRunningTask;
    //use the result 
    Console.WriteLine(result);
}

public async Task<int> LongRunningOperationAsync() // assume we return an int from this long running operation 
{
    await Task.Delay(1000); // 1 second delay
    return 1;
}

So this is what happens in the code above:

1. Task<int> longRunningTask = LongRunningOperationAsync(); starts running LongRunningOperation

2. Non- dependent work is finished on let's say some main thread (Thread ID = 1) then await LongRunningTask is reached.

MyMethodAsync() will now return to the calling method if the longRunningTask hasn't finished yet, preventing the main thread from becoming blocked. Any thread from the ThreadPool will return to MyMethodAsync() in its previous context after the longRunningTask has completed and continue to run (in this case printing the result to the console).