async, await and Task

A Task (or Task<T>) is a promise of a result that may not exist yet. An async method is one the compiler rewrites into a state machine so that await can suspend it without blocking a thread:

1. The caller calls the method. Its body runs synchronously, on the caller's thread, up to the first await of something that has not finished yet.
2. At that point the method returns an incomplete Task to the caller, and registers the rest of its body as a continuation.
3. When the awaited operation completes, the continuation runs and eventually completes the returned Task with a value or an exception.

If every awaited thing is already complete, the method runs to the end synchronously and returns a completed task.

Exceptions are stored in the task

Inside an async method, a thrown exception does not escape the call. It is caught by the generated state machine and stored in the returned task, which becomes Faulted. It is rethrown when someone awaits the task (or calls GetAwaiter().GetResult()). A plain method that returns a Task has no such machinery: if it throws, it throws at the call.

1public static class Solution2{3    static async Task<int> FailsAsync()4    {5        throw new InvalidOperationException("from async");6    }7 8    static Task<int> FailsEagerly()9    {10        throw new InvalidOperationException("from plain method");11    }12 13    public static string Describe()14    {15        var log = new List<string>();16 17        Task<int> t = FailsAsync();                 // no exception here18        log.Add("async call returned, status=" + t.Status);19        try { t.GetAwaiter().GetResult(); }20        catch (InvalidOperationException e) { log.Add("thrown when awaited: " + e.Message); }21 22        try { FailsEagerly(); log.Add("plain call returned"); }23        catch (InvalidOperationException e) { log.Add("thrown at the call: " + e.Message); }24 25        return string.Join(" | ", log);26    }27}

That difference matters for argument checks. In an async method, a check like if (id < 0) throw ... produces a faulted task, so the caller only finds out when it awaits, possibly much later. The usual fix is a non-async public method that validates and then returns the task of a private async method, which the exercise asks you to write.

Calling starts, awaiting waits

Calling an async method starts its work. await only waits for it. So await inside a loop runs the operations one after another, while starting them all first and then awaiting Task.WhenAll lets them overlap:

1public static class Solution2{3    static async Task<int> Fetch(int id, List<string> log)4    {5        lock (log) log.Add("start " + id);6        await Task.Delay(20);7        return id * 10;8    }9 10    static async Task<string> RunAsync()11    {12        var log = new List<string>();13 14        // One at a time: each await finishes before the next call starts.15        int seqTotal = 0;16        foreach (var id in new[] { 1, 2, 3 })17        {18            seqTotal += await Fetch(id, log);19            lock (log) log.Add("done " + id);20        }21 22        // All at once: calling starts each task; WhenAll waits for them together.23        var tasks = new[] { 4, 5, 6 }.Select(id => Fetch(id, log)).ToList();24        lock (log) log.Add("all started");25        int[] results = await Task.WhenAll(tasks);26        log.Add("results " + string.Join(",", results));27 28        return $"seq total={seqTotal} | " + string.Join(", ", log);29    }30 31    public static string Describe() => RunAsync().GetAwaiter().GetResult();32}

In the sequential half each start is followed by its done. In the second half all three starts are logged before all started, because each call ran synchronously up to its await Task.Delay and returned. Task.WhenAll then returns the results in the order the tasks were passed, regardless of which finished first.

Common mistakes

• async void. Nothing can await it, and an exception thrown in it cannot be caught by the caller; it is raised on the synchronisation context or thread pool and typically crashes the process. Use async Task; async void exists only for event handlers.
• Awaiting inside a loop when the operations are independent. They run one at a time. Start them, then await Task.WhenAll(tasks).
• Validating arguments inside an async method. The exception is deferred into the task, as shown above.
• Forgetting await. The call starts the work and the method moves on; an exception in that task goes unobserved. The compiler warns (CS4014) when a task-returning call inside an async method is not awaited.

What interviewers ask

• "Does create a new thread?" No. It suspends the method and frees the current thread; the continuation runs later, on the captured context or a thread-pool thread.