C# Asynchronous Programming: 3 Practical Examples

Introduction to C# Asynchronous Programming

Asynchronous programming in C# allows developers to write code that can run in a non-blocking manner, improving the responsiveness of applications. The async and await keywords simplify the process of working with asynchronous operations by allowing developers to write code that looks synchronous while still being asynchronous under the hood. This approach is particularly useful when dealing with I/O-bound tasks, such as web requests or file operations.

Example 1: Fetching Data from a Web API

Context

In many applications, you may need to fetch data from an external web service. Using asynchronous programming can prevent your application from freezing while waiting for the response.

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

class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://jsonplaceholder.typicode.com/posts";
        var result = await FetchDataAsync(url);
        Console.WriteLine(result);
    }

    static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsStringAsync();
        }
    }
}

Notes

• Ensure to include proper error handling in production code.
• This example uses HttpClient, which is best used as a singleton to avoid socket exhaustion.

Example 2: Reading Files Asynchronously

Context

When dealing with large files, reading them synchronously can lead to performance issues. Asynchronous file I/O operations can significantly improve application responsiveness.

using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string filePath = "example.txt";
        string content = await ReadFileAsync(filePath);
        Console.WriteLine(content);
    }

    static async Task<string> ReadFileAsync(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            return await reader.ReadToEndAsync();
        }
    }
}

Notes

• Ensure that the file exists and the path is correct to avoid exceptions.
• This method is particularly useful for applications that need to process multiple files concurrently.

Example 3: Simulating a Long-Running Task

Context

In scenarios where you need to perform a long-running operation, such as a computation or a data processing task, using asynchronous programming can keep your application responsive to user input.

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting long-running task...");
        int result = await LongRunningOperationAsync();
        Console.WriteLine($"Task completed with result: {result}");
    }

    static async Task<int> LongRunningOperationAsync()
    {
        return await Task.Run(() =>
        {
            Thread.Sleep(5000); // Simulating a delay
            return 42; // Result of the operation
        });
    }
}

Notes

• Task.Run is used here to offload work to a background thread.
• Be cautious with Thread.Sleep in production code; instead, use more efficient methods for delays or waiting.

By incorporating these examples into your programming toolkit, you can effectively utilize C# asynchronous programming with async/await to create more responsive and efficient applications.