How async execution flows in C Sharp (C#) - Practice Exercises

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of async method with Task.Delay

What is the output of this C# program when run?

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        Console.WriteLine("Start");
        await Task.Delay(100);
        Console.WriteLine("End");
    }
}

A Start

B End\nStart

C End

D Start\nEnd

💡 Hint

Remember that await pauses the method until the delay finishes.

The program prints "Start" first, then awaits Task.Delay(100), which pauses asynchronously, then prints "End" after the delay.

❓ Predict Output

intermediate

Order of execution with async void

What will be printed when this program runs?

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program {
    static async void PrintAsync() {
        Console.WriteLine("Before delay");
        await Task.Delay(50);
        Console.WriteLine("After delay");
    }

    static void Main() {
        PrintAsync();
        Console.WriteLine("Main finished");
        Task.Delay(100).Wait();
    }
}

A Main finished\nBefore delay\nAfter delay

B Before delay\nMain finished\nAfter delay

C Before delay\nAfter delay\nMain finished

D Main finished\nAfter delay\nBefore delay

💡 Hint

async void methods start running synchronously until the first await.

PrintAsync prints "Before delay" synchronously, then awaits Task.Delay(50). Meanwhile, Main prints "Main finished" and waits 100ms to keep the program alive. After delay, "After delay" is printed.

🔧 Debug

advanced

Identify the cause of deadlock in async code

This code causes a deadlock when run. What is the reason?

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program {
    static void Main() {
        var result = GetData().Result;
        Console.WriteLine(result);
    }

    static async Task<string> GetData() {
        await Task.Delay(100);
        return "Done";
    }
}

A Blocking on .Result causes deadlock because the async method tries to resume on the captured context which is blocked.

B Task.Delay(100) throws an exception causing deadlock.

C The async method GetData is missing await keyword causing deadlock.

D Console.WriteLine blocks the thread causing deadlock.

💡 Hint

Think about how .Result blocks the main thread and how async continuations work.

Calling .Result blocks the main thread waiting for the async method to complete. The async method tries to resume on the same thread (captured context), but that thread is blocked, causing a deadlock.

❓ Predict Output

advanced

Output of async method with ConfigureAwait(false)

What will this program print?

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        Console.WriteLine("Start");
        await PrintMessageAsync();
        Console.WriteLine("End");
    }

    static async Task PrintMessageAsync() {
        await Task.Delay(50).ConfigureAwait(false);
        Console.WriteLine("Inside async method");
    }
}

A Start\nInside async method\nEnd

B Start\nEnd\nInside async method

C Inside async method\nStart\nEnd

D Start\nEnd

💡 Hint

ConfigureAwait(false) affects context capture but does not change the order of awaited code.

The method prints "Start", then awaits PrintMessageAsync. Inside PrintMessageAsync, after the delay, it prints "Inside async method". Then Main prints "End". The order is preserved.

🧠 Conceptual

expert

Understanding async execution and thread usage

Which statement best describes how async/await affects thread usage in C#?

A Async/await creates a new thread for each awaited operation to run in parallel.

B Async/await blocks the current thread until the awaited task completes, then continues synchronously.

C Async/await frees the current thread during awaits, allowing it to do other work, and resumes on a thread from the thread pool or the captured context.

D Async/await guarantees that code after await runs on the same thread that started the async method.

💡 Hint

Think about what happens to the thread when an await is hit.

When an await is reached, the current thread is freed to do other work. The continuation resumes later on a thread from the thread pool or the original synchronization context if captured.