Async/Await Implementation Patterns

Async/await in C# provides syntactic sugar for asynchronous programming, similar to how yield implements IEnumerable interfaces.

Blocking Methods Comparison

Usage Patterns:

• await works with methods returning Task or Task<T>
• .Wait() and .GetAwaiter().GetResult() work with Task or Task<T> return types
• .Result only works with Task<T> return types

Behavior Differences:

• await suspends method execution without blocking the current thread
• .Result, .Wait(), and .GetAwaiter().GetResult() block the current thread while starting background execution
• .GetAwaiter().GetResult() throws the actual exception instead of AggregateException
• .Result and .Wait() wrap exceptions in AggregateException

Key distinction:

• Blocking method execution
• Blocking thread execution

Practical Example

class Program
{
    [STAThread]
    static void Main()
    {
        Console.WriteLine("Main thread ID: " + Thread.CurrentThread.ManagedThreadId);
        
        // Task creation method 1
        Task workerTask = new Task(() => WorkerMethod());
        workerTask.Start();

        // Task creation method 2
        var resultTask = Task.Run<string>(() => { return FetchData(); });
        Console.WriteLine(resultTask.Result);

        Console.WriteLine("---");
        Console.WriteLine("Main thread ID: {0}", Thread.CurrentThread.ManagedThreadId);
        
        var asyncResult = ExecuteAsyncOperation();
        asyncResult.GetAwaiter().OnCompleted(() => {
            Console.WriteLine("Operation completed with ID: " + asyncResult.Id);
        });

        var output = asyncResult.Result;
        RunTest();
        Console.WriteLine("Main thread finished");
        Console.ReadKey();
    }

    static async Task ExecuteAsyncOperation()
    {
        Console.WriteLine("Before async call - Thread: {0}, Time: {1}", 
            Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd hh:MM:ss"));
        
        var dataTask = RetrieveAsyncData();
        Console.WriteLine("After async call - Thread: {0}, Time: {1}", 
            Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd hh:MM:ss"));
        
        Console.WriteLine("Async result 1: {0}, Time: {1}", await dataTask,
            DateTime.Now.ToString("yyyy-MM-dd hh:MM:ss"));
        Console.WriteLine("Async result 2: {0}, Time: {1}", dataTask.GetAwaiter().GetResult(),
            DateTime.Now.ToString("yyyy-MM-dd hh:MM:ss"));
    }

    static async Task<string> RetrieveAsyncData()
    {
        Console.WriteLine("Before Task.Run - Thread: {0}", Thread.CurrentThread.ManagedThreadId);

        return await Task.Run(() =>
        {
            Thread.Sleep(2000);
            Console.WriteLine("Inside async method - Thread: {0}", Thread.CurrentThread.ManagedThreadId);
            return "Operation completed";
        });
    }

    static void WorkerMethod()
    {
        Console.WriteLine("Worker thread ID: " + Thread.CurrentThread.ManagedThreadId);
    }

    static string FetchData()
    {
        return "Data result - Thread: " + Thread.CurrentThread.ManagedThreadId;
    }
    
    static async void RunTest()
    {
        Console.WriteLine("Test thread ID: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Run(() => {
            Thread.Sleep(1000);
            Console.WriteLine("Test method execution started");
        });
        Console.WriteLine("Test thread ID: " + Thread.CurrentThread.ManagedThreadId);
    }
}

Execution Context Fundamentals

Execution context enables propagation of thread-specific data across asynchronous operations, addressing limitations of thread-local storage. It automatically transfers:

• Security context
• Host environment settings
• Logical call context data
• Culture information (from .NET 4.6)

Synchronization Context Mechanisms

Synchronization context defines asynchronous completion behavior through two primary methods:

• Send: Synchronously waits for task completion
• Post: Queues work without waiting

When asynchronous operations begin, the current synchronization context is captured and stored. Upon completion, the context is restored using Send or Post methods.

Common implementations include:

• UI synchronization context: Marhsals work to UI thread via message queue
• ASP.NET context: Maintains thread identity and culture across operations
• Default context: Uses thread pool scheduler without special handling

ConfigureAwait(false) bypasses synchronization context restoration, which can improve performance but may cause issues in UI scenarios.

Underlying Execution Model

Asynchronous operations are typical handled by thread pool I/O completion threads. Consider this example:

async void LoadImage_Click(object sender, EventArgs e)
{
    Task<Image> iconTask = LoadIconAsync(targetUrl);

    Image iconImage = await iconTask;

    DisplayIcon(iconImage);
}

async Task<Image> LoadIconAsync(string url)
{
    var downloadTask = httpClient.DownloadDataTaskAsync(url);

    byte[] imageData = await downloadTask;

    return CreateImage(imageData);
}

The execution flow involves:

• User thread initiates operation
• I/O completion threads handle underlying work
• Synchroniaztion context resumes remaining work on appropriate thread