MSDN Documentation | .NET

What is Asynchronous Programming?

Traditionally, applications execute code sequentially. When an operation takes a long time (e.g., network requests, disk I/O, complex calculations), the application can become unresponsive. Asynchronous programming allows your application to initiate a long-running operation and continue with other tasks while waiting for the operation to complete, without blocking the main thread.

Key benefits include:

• Improved responsiveness of UI applications.
• Increased scalability and throughput for server applications.
• Efficient utilization of system resources.

Introducing async and await

C# 5.0 introduced the async and await keywords, which dramatically simplify asynchronous programming. They enable you to write asynchronous code that looks and behaves much like synchronous code, making it easier to read, write, and maintain.

The async keyword marks a method as asynchronous. The await keyword is used within an async method to pause execution until an awaitable operation (typically a Task or Task<TResult>) completes. While awaiting, the thread is not blocked and can be used for other work.

Example: A Simple Asynchronous Method

using System;
using System.Threading.Tasks;

public class AsyncExample
{
    public async Task DownloadDataAsync(string url)
    {
        Console.WriteLine($"Starting download from: {url}");
        // Simulate a long-running download operation
        await Task.Delay(3000); // Pause for 3 seconds
        Console.WriteLine($"Finished download from: {url}");
        return $"Downloaded content from {url}";
    }

    public async Task RunAsync()
    {
        Console.WriteLine("Main thread started.");
        string result = await DownloadDataAsync("http://example.com");
        Console.WriteLine($"Received: {result}");
        Console.WriteLine("Main thread finished.");
    }

    public static async Task Main(string[] args)
    {
        var example = new AsyncExample();
        await example.RunAsync();
    }
}
                

Understanding Task and Task<TResult>

Task represents an asynchronous operation that does not return a value. Task<TResult> represents an asynchronous operation that returns a value of type TResult. These types are central to the Task Parallel Library (TPL), which underpins async/await.

When you await a Task, the execution of the current method is suspended. Control is returned to the caller of the method until the awaited operation completes. Then, execution resumes where it left off.

Common Asynchronous Patterns

• Fire and Forget: Initiating an asynchronous operation without awaiting its completion. This is generally discouraged unless you have a specific reason and handle potential exceptions.
• Task Composition: Combining multiple asynchronous operations using methods like Task.WhenAll (to wait for all tasks to complete) and Task.WhenAny (to wait for the first task to complete).
• Cancellation: Implementing mechanisms to cancel long-running asynchronous operations gracefully using CancellationToken.

Example: Using Task.WhenAll

public async Task ProcessMultipleUrlsAsync()
{
    var urls = new[] { "url1", "url2", "url3" };
    var downloadTasks = new List<Task<string>>();

    foreach (var url in urls)
    {
        downloadTasks.Add(DownloadDataAsync(url));
    }

    // Wait for all downloads to complete
    string[] results = await Task.WhenAll(downloadTasks);

    Console.WriteLine("All downloads completed.");
    foreach (var result in results)
    {
        Console.WriteLine(result);
    }
}
                

Best Practices for Asynchronous Code

• Always await when you call an asynchronous method. Unless you explicitly intend to "fire and forget".
• Use ConfigureAwait(false) in library code to avoid deadlocks and improve performance by not trying to resume on the original synchronization context.
• Handle exceptions properly. Exceptions thrown by awaited tasks will propagate to the point of the await.
• Prefer ValueTask<TResult> over Task<TResult> for high-performance scenarios where the result might be available synchronously.
• Be consistent. Choose an asynchronous pattern and stick with it throughout your project.