Async And Await In C# Complete Guide

Step 1: Understanding Basics

• async: A modifier used to indicate that a method, lambda expression, or anonymous method is asynchronous. When you use async, the compiler generates the necessary boilerplate to make the method work asynchronously.
• await: An operator used to suspend the execution of a method until the awaited task completes.

Step 2: Setting Up the Environment

Ensure you have Visual Studio installed or you can use Visual Studio Code with the .NET SDK installed. We'll be writing our code in C#.

Step 3: Simple Example with Console Application

Let's create a simple console application that demonstrates the use of async and await.

Step 3.1: Create a Console Application

1. Open Visual Studio.
2. Create a new project → Console App (.NET Core or .NET 5/6/7).
3. Give it a name, e.g., AsyncAwaitExample.

Step 3.2: Modify Program.cs

Replace the contents of Program.cs with the following code:

using System;
using System.Threading.Tasks;

namespace AsyncAwaitExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Main method started...");

            // Call the asynchronous method
            await DoWorkAsync();

            Console.WriteLine("Main method ended...");
        }

        static async Task DoWorkAsync()
        {
            Console.WriteLine("Doing work asynchronously...");

            // Simulate a time-consuming operation using Task.Delay
            await Task.Delay(2000); // Delay for 2 seconds

            Console.WriteLine("Work completed asynchronously...");
        }
    }
}

Explanation:

• Main method: The Main method is now an async Task method. This is necessary to use the await keyword inside it.
• DoWorkAsync method: This method does some work asynchronously using Task.Delay, which simulates a long-running operation.

Step 3.3: Run the Application

• Press F5 to run the application.
• You should see the following output:

  Main method started...
  Doing work asynchronously...
  Work completed asynchronously...
  Main method ended...
  

The await Task.Delay(2000) pauses the method for 2 seconds without blocking the main thread. This is the core idea of async/await.

Step 4: Handling Exceptions

Handling exceptions in asynchronous methods is also important.

Step 4.1: Modify DoWorkAsync to Include Exception Handling

Replace the DoWorkAsync method with the following code:

static async Task DoWorkAsync()
{
    Console.WriteLine("Doing work asynchronously...");

    try
    {
        // Simulate a time-consuming operation using Task.Delay
        await Task.Delay(2000); // Delay for 2 seconds

        // Simulate an exception
        throw new InvalidOperationException("An error occurred!");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception caught: {ex.Message}");
    }

    Console.WriteLine("Work completed asynchronously...");
}

Step 4.2: Run the Application Again

• Press F5 to run the application.
• You should see the following output:

  Main method started...
  Doing work asynchronously...
  Exception caught: An error occurred!
  Work completed asynchronously...
  Main method ended...
  

Step 5: Using async/await with I/O Operations

Async/await is especially useful for I/O-bound operations, such as reading from or writing to files, or database access.

Step 5.1: Add File Operations

Let's modify our DoWorkAsync method to read from and write to a file asynchronously.

static async Task DoWorkAsync()
{
    string path = "example.txt";

    Console.WriteLine("Doing work asynchronously...");

    try
    {
        // Simulate a time-consuming I/O operation using File.WriteAllTextAsync and File.ReadAllTextAsync
        await File.WriteAllTextAsync(path, "This is an example of writing to a file asynchronously.");

        string content = await File.ReadAllTextAsync(path);
        Console.WriteLine($"Content of the file: {content}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception caught: {ex.Message}");
    }

    Console.WriteLine("Work completed asynchronously...");
}

Step 5.2: Run the Application Again

• Press F5 to run the application.
• You should see the following output:

  Main method started...
  Doing work asynchronously...
  Content of the file: This is an example of writing to a file asynchronously.
  Work completed asynchronously...
  Main method ended...
  

The application writes some text to a file and then reads it back, both operations are performed asynchronously.

Step 6: Using async/await with Multiple Tasks

You can also use await with multiple tasks concurrently.

Step 6.1: Modify DoWorkAsync to Run Multiple Tasks at Once

Replace the DoWorkAsync method with the following code:

static async Task DoWorkAsync()
{
    string path1 = "example1.txt";
    string path2 = "example2.txt";

    Console.WriteLine("Doing work asynchronously...");

    try
    {
        // Create two tasks
        Task writeTask1 = File.WriteAllTextAsync(path1, "This is the first file.");
        Task writeTask2 = File.WriteAllTextAsync(path2, "This is the second file.");

        // Wait for both tasks to complete
        await Task.WhenAll(writeTask1, writeTask2);

        Console.WriteLine("Both files have been written.");

        // Read the files concurrently
        Task<string> readTask1 = File.ReadAllTextAsync(path1);
        Task<string> readTask2 = File.ReadAllTextAsync(path2);

        string content1 = await readTask1;
        string content2 = await readTask2;

        Console.WriteLine($"Content of the first file: {content1}");
        Console.WriteLine($"Content of the second file: {content2}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception caught: {ex.Message}");
    }

    Console.WriteLine("Work completed asynchronously...");
}

Step 6.2: Run the Application Again

• Press F5 to run the application.
• You should see the following output:

  Main method started...
  Doing work asynchronously...
  Both files have been written.
  Content of the first file: This is the first file.
  Content of the second file: This is the second file.
  Work completed asynchronously...
  Main method ended...
  

The application writes to two files concurrently, waits for both to finish, and then reads from both files concurrently.

Summary

In this guide, we covered the basics of async and await in C# with several examples:

1. A simple example simulating work with Task.Delay.
2. Exception handling in asynchronous methods.
3. Using async/await with I/O operations.
4. Running multiple tasks concurrently.