What do the async and await keywords actually do? Explain what happens when execution reaches an await.

1. The awaitable pattern

The compiler only needs:

TAwaiter GetAwaiter();                 // instance or extension method
// TAwaiter must have:
bool IsCompleted { get; }
void OnCompleted(Action continuation);  // INotifyCompletion (and optionally ICriticalNotifyCompletion.UnsafeOnCompleted)
T GetResult();                          // or void

That's why you can await a Task, a ValueTask, Task.Yield(), ConfiguredTaskAwaitable, a TimeSpan (with an extension), or your own types.

2. Simplified lowering

async Task<int> GetAsync()
{
    var a = await LoadAsync();
    return a + 1;
}

becomes roughly:

void MoveNext()
{
    int result;
    try
    {
        TaskAwaiter<int> aw;
        if (state == 0) { aw = savedAwaiter; state = -1; goto Resume; }
        aw = LoadAsync().GetAwaiter();
        if (!aw.IsCompleted)
        {
            state = 0; savedAwaiter = aw;
            builder.AwaitUnsafeOnCompleted(ref aw, ref this);  // box (first time) + register
            return;                                             // yield to caller
        }
    Resume:
        int a = aw.GetResult();
        result = a + 1;
    }
    catch (Exception ex) { state = -2; builder.SetException(ex); return; }
    state = -2;
    builder.SetResult(result);
}

The next question goes deeper into the state machine itself.

3. Exceptions before the first await

Task t = ValidateAsync(null);    // no exception here
await t;                         // ArgumentNullException surfaces here

async Task ValidateAsync(string? s)
{
    ArgumentNullException.ThrowIfNull(s);   // stored in the task
    await Task.Yield();
}

If you need argument validation to throw eagerly, split into a non-async public method that validates and an async private implementation (or use a local function).

4. Task.Yield() and forcing asynchrony

await Task.Yield() always reports IsCompleted == false, so the method always yields and the rest runs as a scheduled continuation. Useful in tests, in UI code to let the message loop run, or to avoid deep synchronous recursion. It's not a way to "run in the background" in ASP.NET Core; it just requeues to the pool.

5. Context capture in detail

await SomethingAsync();                     // captures SynchronizationContext.Current (if any)
await SomethingAsync().ConfigureAwait(false); // doesn't

Capture happens at the await, only if the awaitable is incomplete. If SynchronizationContext.Current is null and TaskScheduler.Current is the default, there's nothing to capture, so the continuation can run directly on the completing thread or be queued to the pool.

6. Eliding async: when it's safe

7. Version notes

8. Try it yourself

1. Run the code example: compare thread ids before/after the fast and slow awaits.
2. Throw before the first await, call without awaiting, check IsFaulted, then await.
3. Write a custom awaitable (GetAwaiter extension on TimeSpan) and await TimeSpan.FromSeconds(1).
4. In a WPF app, print the thread id after await with and without ConfigureAwait(false).
5. Elide async in a method with using var conn = ... and observe ObjectDisposedException.
6. Decompile an async method with SharpLab and find the IsCompleted check.

Console.WriteLine($"Main start on thread {Environment.CurrentManagedThreadId}");

Task<int> pending = ComputeAsync(fast: false); // returns at the first incomplete await
Console.WriteLine("Caller continues while ComputeAsync waits");
Console.WriteLine($"Result {await pending}");

Console.WriteLine($"Fast path result {await ComputeAsync(fast: true)}");

Task faulty = ThrowsEarlyAsync();               // no exception here
Console.WriteLine($"Faulted before await? {faulty.IsFaulted}");
try { await faulty; }
catch (InvalidOperationException ex) { Console.WriteLine($"Observed: {ex.Message}"); }

static async Task<int> ComputeAsync(bool fast)
{
    Console.WriteLine($"  before await on {Environment.CurrentManagedThreadId}");
    if (fast)
        await Task.CompletedTask;   // IsCompleted is true: continues synchronously
    else
        await Task.Delay(100);      // incomplete: method yields
    Console.WriteLine($"  after await on {Environment.CurrentManagedThreadId}");
    return 42;
}

static async Task ThrowsEarlyAsync()
{
    throw new InvalidOperationException("stored in the task");
#pragma warning disable CS0162
    await Task.CompletedTask;
#pragma warning restore CS0162
}