PikoPost
PikoPost β

07 Feb 2024

Intermediate

Asynchronous methods in C# allow you to execute tasks concurrently without blocking the calling thread. This is particularly useful when dealing with I/O-bound operations like network requests, file I/O, or database queries. Asynchronous methods enable your program to perform other tasks while waiting for the asynchronous operation to complete, improving the responsiveness and scalability of your applications.

Example 1:

Let's say we have a method that simulates downloading a file from a remote server synchronously:

using System;
using System.Net;

class Program
{
    static void Main(string[] args)
    {
        string fileUrl = "https://example.com/sample-file.txt";
        string fileContent = DownloadFile(fileUrl);
        Console.WriteLine(fileContent);
    }

    static string DownloadFile(string url)
    {
        WebClient client = new WebClient();
        return client.DownloadString(url);
    }
}

In this synchronous version, the DownloadFile method blocks the main thread until the file is fully downloaded, which can make the application unresponsive, especially for larger files or slower connections.

To make this operation asynchronous, we can use the async and await keywords along with the Task class. Here's how we can rewrite the code to use asynchronous methods:

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

class Program
{
    static async Task Main(string[] args)
    {
        string fileUrl = "https://example.com/sample-file.txt";
        string fileContent = await DownloadFileAsync(fileUrl);
        Console.WriteLine(fileContent);
    }

    static async Task<string> DownloadFileAsync(string url)
    {
        WebClient client = new WebClient();
        return await client.DownloadStringTaskAsync(url);
    }
}

In the asynchronous version:

  • The Main method is marked as async, allowing the use of the await keyword.
  • The DownloadFileAsync method is marked as async as well, indicating that it contains asynchronous operations.
  • The DownloadStringTaskAsync method of WebClient returns a Task<string> representing the asynchronous operation of downloading the file content.

When we await the DownloadStringTaskAsync method call, the execution of the Main method is suspended until the file download completes. However, during this time, the thread is free to perform other tasks, making the application responsive.

Once the file download is complete, the execution resumes at the point of the await statement, and the downloaded file content is returned.

In summary, asynchronous methods in C# provide a way to perform non-blocking operations, allowing your application to remain responsive and handle multiple tasks efficiently. They are particularly useful for I/O-bound operations where waiting for completion would otherwise block the thread.

Example 2:

Let's consider a scenario where we need to fetch weather data for multiple cities from a remote API. We'll create a synchronous version first, and then we'll implement an asynchronous version using C#'s async/await pattern.

Synchronous Version:

using System;
using System.Collections.Generic;
using System.Net;

class Program
{
    static void Main(string[] args)
    {
        List<string> cities = new List<string> { "New York", "London", "Tokyo" };

        foreach (string city in cities)
        {
            string weatherData = GetWeatherData(city);
            Console.WriteLine($"{city}: {weatherData}");
        }
    }

    static string GetWeatherData(string city)
    {
        string apiUrl = $"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=YOUR_API_KEY";
        WebClient client = new WebClient();
        return client.DownloadString(apiUrl);
    }
}

In this synchronous version:

  • We have a list of cities for which we want to fetch weather data.
  • We iterate through each city in the list and call the GetWeatherData method to fetch the weather data synchronously.
  • The GetWeatherData method constructs the API URL for the given city and uses WebClient to download the weather data.

Asynchronous Version:

using System;
using System.Collections.Generic;
using System.Net;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        List<string> cities = new List<string> { "New York", "London", "Tokyo" };

        foreach (string city in cities)
        {
            string weatherData = await GetWeatherDataAsync(city);
            Console.WriteLine($"{city}: {weatherData}");
        }
    }

    static async Task<string> GetWeatherDataAsync(string city)
    {
        string apiUrl = $"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=YOUR_API_KEY";
        WebClient client = new WebClient();
        return await client.DownloadStringTaskAsync(apiUrl);
    }
}

In the asynchronous version:

  • The Main method is marked as async, allowing the use of the await keyword.
  • We iterate through each city in the list asynchronously.
  • The GetWeatherDataAsync method is marked as async and returns a Task<string>.
  • We await the DownloadStringTaskAsync method call, which performs an asynchronous download of weather data for the given city.
  • The await keyword ensures that the method asynchronously waits for the completion of the download operation without blocking the main thread.

Explanation:

In both versions, the synchronous and asynchronous, we achieve the same goal of fetching weather data for multiple cities. However, the asynchronous version offers better responsiveness and scalability:

  • In the synchronous version, each call to GetWeatherData blocks the main thread until the weather data is fetched, which could result in a slower overall execution time, especially if there are delays in network requests.

  • In the asynchronous version, we can initiate multiple weather data fetch operations concurrently without blocking the main thread. This allows for better utilization of system resources and improved performance, especially in scenarios where network latency is involved.

Overall, asynchronous programming in C# enables more efficient utilization of system resources and better responsiveness in applications that deal with I/O-bound operations like network requests.

Example 3:

Let's consider a scenario where we need to process a batch of images by applying some image transformation operations. We'll first create a synchronous version of this task, then we'll refactor it into an asynchronous version.

Synchronous Version:

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<string> imagePaths = new List<string>
        {
            "image1.jpg",
            "image2.jpg",
            "image3.jpg"
        };

        foreach (string imagePath in imagePaths)
        {
            ProcessImage(imagePath);
        }

        Console.WriteLine("All images processed successfully.");
    }

    static void ProcessImage(string imagePath)
    {
        // Simulate image processing
        Console.WriteLine($"Processing image: {imagePath}");
        // Perform some image transformation operations
        // (e.g., resizing, cropping, filtering)
        // Simulate processing time
        System.Threading.Thread.Sleep(2000); // 2 seconds
        Console.WriteLine($"Image {imagePath} processed.");
    }
}

In this synchronous version:

  • We have a list of image paths that we want to process.
  • We iterate through each image path in the list and call the ProcessImage method synchronously.
  • The ProcessImage method simulates some image transformation operations and introduces a delay to simulate processing time.

Asynchronous Version:

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        List<string> imagePaths = new List<string>
        {
            "image1.jpg",
            "image2.jpg",
            "image3.jpg"
        };

        List<Task> tasks = new List<Task>();

        foreach (string imagePath in imagePaths)
        {
            tasks.Add(ProcessImageAsync(imagePath));
        }

        await Task.WhenAll(tasks);

        Console.WriteLine("All images processed successfully.");
    }

    static async Task ProcessImageAsync(string imagePath)
    {
        // Simulate image processing
        Console.WriteLine($"Processing image: {imagePath}");
        // Perform some image transformation operations asynchronously
        // Simulate processing time
        await Task.Delay(2000); // 2 seconds
        Console.WriteLine($"Image {imagePath} processed.");
    }
}

In the asynchronous version:

  • The Main method is marked as async, allowing the use of the await keyword.
  • We iterate through each image path in the list asynchronously.
  • The ProcessImageAsync method is marked as async and returns a Task.
  • We add each asynchronous operation to a list of Tasks.
  • We use Task.WhenAll(tasks) to asynchronously wait for all tasks to complete before printing the success message.

Explanation:

In both versions, we achieve the goal of processing a batch of images. However, the asynchronous version offers better responsiveness and concurrency:

  • In the synchronous version, each image processing operation blocks the main thread until it completes. If there are multiple images to process, the overall execution time can be longer due to waiting for each operation to finish sequentially.

  • In the asynchronous version, we can initiate multiple image processing operations concurrently without blocking the main thread. This allows for better utilization of system resources and improved performance, especially when processing multiple images with potentially varying processing times.

Overall, asynchronous programming in C# enables more efficient utilization of system resources and better responsiveness in applications, especially in scenarios involving I/O-bound or CPU-bound operations.

c-sharp
async
await
muku
muku