C# Async Await

In modern applications, responsiveness is crucial. Whether you're building a desktop app, a web service, or a mobile application, you want to ensure your program remains responsive even when performing long-running operations like file I/O, network requests, or database queries.

C#'s async and await keywords provide an elegant way to write asynchronous code that's almost as straightforward as synchronous code but offers significant performance benefits.

Introduction to Async/Await

Async/await is a pattern introduced in C# 5.0 that simplifies writing asynchronous code. Before async/await, developers had to use callback methods, events, or the Task class directly, which often led to complex and hard-to-maintain code known as "callback hell."

The async and await keywords allow you to:

Write asynchronous code that looks similar to synchronous code
Easily handle exceptions with try/catch in asynchronous operations
Return values from asynchronous methods
Perform sequential and parallel asynchronous operations

How Async/Await Works

At its core, async/await is built upon the Task-based Asynchronous Pattern (TAP). Here's how it works:

An async method runs synchronously until it reaches an await expression
When an await is encountered, the method is suspended, and control returns to the caller
When the awaited task completes, execution resumes from where it left off

This means your application remains responsive while waiting for operations to complete.

Basic Syntax

Here's the basic syntax of an async method:

csharp
async Task<TResult> MethodNameAsync()
{
    // Asynchronous operations
    TResult result = await SomeAsyncOperation();
    return result;
}

If your method doesn't return a value, use Task instead:

csharp
async Task MethodNameAsync()
{
    // Asynchronous operations
    await SomeAsyncOperation();
}

💡 Naming Convention: By convention, async methods end with the "Async" suffix.

Your First Async Method

Let's start with a simple example - downloading a web page asynchronously:

csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        Console.WriteLine("Starting web request...");
        
        string content = await DownloadWebpageAsync("https://example.com");
        
        Console.WriteLine($"Downloaded {content.Length} characters");
        Console.WriteLine("Program completed!");
    }
    
    private static async Task<string> DownloadWebpageAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            Console.WriteLine("Downloading...");
            string content = await client.GetStringAsync(url);
            Console.WriteLine("Download completed!");
            return content;
        }
    }
}

Output:

Starting web request...
Downloading...
Download completed!
Downloaded 1256 characters
Program completed!

This example:

Calls an asynchronous method DownloadWebpageAsync
Uses await to wait for the result without blocking the thread
Continues execution after the download completes

Async Method Return Types

Async methods can have three possible return types:

Task<T> - When your method returns a value of type T asynchronously
Task - When your method performs an operation but doesn't return a value
void - Only used for event handlers (not recommended for other scenarios)
ValueTask<T> / ValueTask - More efficient alternatives when async operations might complete synchronously

Error Handling

One of the great benefits of async/await is that you can use familiar try/catch blocks for error handling:

csharp
public static async Task Main()
{
    try
    {
        string content = await DownloadWebpageAsync("https://invalid-url.example");
        Console.WriteLine($"Downloaded {content.Length} characters");
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"Error downloading page: {ex.Message}");
    }
    finally
    {
        Console.WriteLine("Operation attempted.");
    }
}

Sequential vs Parallel Execution

Sequential Execution

To execute async operations one after another:

csharp
async Task SequentialDownloadsAsync()
{
    string content1 = await DownloadWebpageAsync("https://example.com/page1");
    string content2 = await DownloadWebpageAsync("https://example.com/page2");
    
    Console.WriteLine($"Total characters: {content1.Length + content2.Length}");
}

Parallel Execution

To execute async operations concurrently:

csharp
async Task ParallelDownloadsAsync()
{
    Task<string> download1 = DownloadWebpageAsync("https://example.com/page1");
    Task<string> download2 = DownloadWebpageAsync("https://example.com/page2");
    
    // Start both downloads before awaiting either
    
    string content1 = await download1;
    string content2 = await download2;
    
    Console.WriteLine($"Total characters: {content1.Length + content2.Length}");
}

You can also use Task.WhenAll to await multiple tasks:

csharp
async Task ParallelDownloadsWithWhenAllAsync()
{
    Task<string> download1 = DownloadWebpageAsync("https://example.com/page1");
    Task<string> download2 = DownloadWebpageAsync("https://example.com/page2");
    
    string[] results = await Task.WhenAll(download1, download2);
    
    Console.WriteLine($"Total characters: {results[0].Length + results[1].Length}");
}

Real-World Example: Building a Weather App

Let's create a more practical example - a weather application that fetches data from multiple sources:

csharp
public class WeatherApp
{
    private readonly HttpClient _client;
    
    public WeatherApp()
    {
        _client = new HttpClient();
    }
    
    public async Task<WeatherReport> GetWeatherReportAsync(string city)
    {
        Console.WriteLine($"Getting weather report for {city}...");
        
        // Start all requests in parallel
        Task<double> temperatureTask = GetTemperatureAsync(city);
        Task<int> humidityTask = GetHumidityAsync(city);
        Task<string> forecastTask = GetForecastAsync(city);
        
        // Await all tasks to complete
        await Task.WhenAll(temperatureTask, humidityTask, forecastTask);
        
        // Create the report using results
        WeatherReport report = new WeatherReport
        {
            City = city,
            Temperature = await temperatureTask,
            Humidity = await humidityTask,
            Forecast = await forecastTask,
            ReportTime = DateTime.Now
        };
        
        return report;
    }
    
    private async Task<double> GetTemperatureAsync(string city)
    {
        await Task.Delay(1000); // Simulate API call
        return 25.5; // Simplified example
    }
    
    private async Task<int> GetHumidityAsync(string city)
    {
        await Task.Delay(800); // Simulate API call
        return 65; // Simplified example
    }
    
    private async Task<string> GetForecastAsync(string city)
    {
        await Task.Delay(1200); // Simulate API call
        return "Partly cloudy"; // Simplified example
    }
}

public class WeatherReport
{
    public string City { get; set; }
    public double Temperature { get; set; }
    public int Humidity { get; set; }
    public string Forecast { get; set; }
    public DateTime ReportTime { get; set; }
    
    public override string ToString()
    {
        return $"Weather for {City} at {ReportTime:t}:\n" +
               $"Temperature: {Temperature}°C\n" +
               $"Humidity: {Humidity}%\n" +
               $"Forecast: {Forecast}";
    }
}

Usage:

csharp
public static async Task Main()
{
    WeatherApp app = new WeatherApp();
    
    WeatherReport report = await app.GetWeatherReportAsync("Seattle");
    Console.WriteLine(report);
}

Output:

Getting weather report for Seattle...
Weather for Seattle at 3:45 PM:
Temperature: 25.5°C
Humidity: 65%
Forecast: Partly cloudy

This example demonstrates:

Parallel execution of multiple async operations
Using Task.WhenAll to wait for all operations to complete
Organizing async code in a clean, maintainable way

Common Pitfalls and Best Practices

Avoid async void

Only use async void for event handlers. For all other cases, use async Task because:

async void methods cannot be awaited
Exceptions in async void methods can crash the application
They're harder to test

csharp
// Good
public async Task ProcessDataAsync() { ... }

// Bad (except for event handlers)
public async void ProcessData() { ... }

Don't Forget to Await Tasks

Always await Task objects or explicitly handle them:

csharp
// Wrong: The task runs but you're not waiting for it
public void DoWork()
{
    SomeAsyncMethod(); // Fire and forget - this is usually a bug!
}

// Correct: You're awaiting the task
public async Task DoWorkAsync()
{
    await SomeAsyncMethod();
}

Use ConfigureAwait(false) When Appropriate

In libraries, consider using ConfigureAwait(false) to avoid forcing the continuation back to the original context:

csharp
// In a library method
public async Task<string> GetDataFromDatabaseAsync()
{
    // No need to return to the original context
    return await dbConnection.QueryAsync("SELECT * FROM Users")
        .ConfigureAwait(false);
}

Don't Mix Blocking and Async Code

Avoid calling .Wait(), .Result, or .GetAwaiter().GetResult() on tasks as it can lead to deadlocks:

csharp
// Wrong: Can cause deadlocks
public string GetData()
{
    return GetDataAsync().Result; // Potential deadlock!
}

// Correct: Keep the async chain
public async Task<string> GetDataAsync()
{
    return await FetchDataAsync();
}

Summary

Async and await in C# provide a powerful yet simple way to write asynchronous code. They allow you to:

Keep your application responsive by not blocking threads during I/O operations
Write asynchronous code that's as readable as synchronous code
Handle exceptions with traditional try/catch blocks
Execute async operations sequentially or in parallel

By mastering async/await, you'll be able to build responsive, efficient applications that can handle many concurrent operations without sacrificing code readability or maintainability.

Exercises

Create a console application that downloads content from multiple websites simultaneously and displays the total character count.
Modify the weather app example to handle timeouts and retry failed requests.
Write a method that reads multiple files asynchronously and combines their contents.
Create a simple file backup utility that copies files asynchronously with a progress report.

Additional Resources

Happy coding with async/await!

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)

Introduction to Async/Await​

How Async/Await Works​

Basic Syntax​

Your First Async Method​

Async Method Return Types​

Error Handling​

Sequential vs Parallel Execution​

Sequential Execution​

Parallel Execution​

Real-World Example: Building a Weather App​

Common Pitfalls and Best Practices​

Avoid async void​

Don't Forget to Await Tasks​

Use ConfigureAwait(false) When Appropriate​

Don't Mix Blocking and Async Code​

Summary​

Exercises​

Additional Resources​