The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Asynchronous Programming

Next ►
►

Asynchronous programming is a form of parallel programming that allows a unit of work to run separately from the main application thread. When the work is complete, it notifies the main thread (or another thread) about its completion. This is particularly useful for tasks that are I/O-bound or require waiting, such as reading from a file, making network requests, or querying a database.

Key Concepts

  1. Synchronous vs Asynchronous:

    • Synchronous: Tasks are performed one after another. Each task must complete before the next one starts.
    • Asynchronous: Tasks can be performed concurrently. A task can start before the previous one finishes.

  2. Tasks and Task-based Asynchronous Pattern (TAP):

    • Task: Represents an asynchronous operation.
    • Task-based Asynchronous Pattern (TAP): A pattern for asynchronous programming using the Task and Task<T> types.

  3. Async and Await Keywords:

    • async: Used to declare a method as asynchronous.
    • await: Used to pause the execution of an async method until the awaited task completes.

  4. Asynchronous Methods:

    • Methods that perform asynchronous operations and return Task or Task<T>.

Practical Examples

Example 1: Basic Asynchronous Method

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting Main method...");
        await PerformTaskAsync();
        Console.WriteLine("Main method complete.");
    }

    static async Task PerformTaskAsync()
    {
        Console.WriteLine("Starting PerformTaskAsync...");
        await Task.Delay(2000); // Simulates a delay of 2 seconds
        Console.WriteLine("PerformTaskAsync complete.");
    }
}

Explanation:

  • Main method is marked with async and returns Task.
  • await PerformTaskAsync() pauses the Main method until PerformTaskAsync completes.
  • Task.Delay(2000) simulates a 2-second delay asynchronously.

Example 2: Returning a Value from an Asynchronous Method

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting Main method...");
        int result = await CalculateSumAsync(5, 10);
        Console.WriteLine($"Sum: {result}");
        Console.WriteLine("Main method complete.");
    }

    static async Task<int> CalculateSumAsync(int a, int b)
    {
        Console.WriteLine("Starting CalculateSumAsync...");
        await Task.Delay(1000); // Simulates a delay of 1 second
        int sum = a + b;
        Console.WriteLine("CalculateSumAsync complete.");
        return sum;
    }
}

Explanation:

  • CalculateSumAsync returns Task<int>, indicating it returns an integer result asynchronously.
  • await CalculateSumAsync(5, 10) pauses the Main method until the sum is calculated and returned.

Practical Exercises

Exercise 1: Asynchronous File Reading

Task: Write an asynchronous method to read the contents of a file and print it to the console.

Solution:

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();
        }
    }
}

Explanation:

  • ReadFileAsync reads the file content asynchronously using StreamReader.ReadToEndAsync.
  • The using statement ensures the StreamReader is disposed of properly.

Exercise 2: Asynchronous Web Request

Task: Write an asynchronous method to fetch data from a web URL and print the response to the console.

Solution:

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/1";
        string response = await FetchDataAsync(url);
        Console.WriteLine(response);
    }

    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();
        }
    }
}

Explanation:

  • FetchDataAsync uses HttpClient to send an asynchronous GET request.
  • HttpResponseMessage is awaited to ensure the request completes before reading the response content.

Common Mistakes and Tips

  1. Blocking the Main Thread:

    • Avoid using .Result or .Wait() on tasks in the main thread, as it can cause deadlocks.
    • Always use await to asynchronously wait for tasks to complete.

  2. Exception Handling:

    • Use try-catch blocks to handle exceptions in asynchronous methods.
    • Exceptions in async methods are propagated to the calling method.

  3. Deadlocks:

    • Be cautious of deadlocks when mixing synchronous and asynchronous code.
    • Prefer fully asynchronous code paths.

Summary

In this section, we covered the basics of asynchronous programming in C#. We learned about the async and await keywords, how to create and use asynchronous methods, and the importance of handling exceptions in asynchronous code. We also provided practical examples and exercises to reinforce the concepts. Asynchronous programming is a powerful tool for improving the responsiveness and performance of your applications, especially when dealing with I/O-bound operations.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved