**Course Title:** Mastering C#: From Fundamentals to Advanced Programming **Section Title:** Asynchronous Programming with C# **Topic:** Write an asynchronous C# program using async/await to handle long-running tasks.(Lab topic) ### Overview In this lab, you will learn how to write an asynchronous C# program using async/await to handle long-running tasks. You will learn how to use the async and await keywords to write asynchronous code that is easier to read and maintain. We will also cover how to handle exceptions in asynchronous code and how to cancel asynchronous operations. ### Prerequisites * Understanding of synchronous programming in C# * Familiarity with asynchronous programming concepts ### What is Async/Await? Async/await is a programming model that allows you to write asynchronous code that is easier to read and maintain. It allows you to write asynchronous code that looks and feels like synchronous code. Async/await is built on top of the Task Parallel Library (TPL) and uses tasks to represent asynchronous operations. When you use async/await, the compiler automatically generates a state machine that manages the asynchronous operation. ### How to Write Asynchronous Code using Async/Await To write asynchronous code using async/await, you need to use the async and await keywords. The async keyword is used to declare an asynchronous method, while the await keyword is used to suspend the execution of the method until the asynchronous operation is complete. Here is an example of an asynchronous method that uses async/await: ```csharp public async Task MyMethodAsync() { // Start an asynchronous operation var task = Task.Run(() => { // Simulate a long-running operation Thread.Sleep(5000); }); // Wait for the operation to complete await task; // Code to execute after the operation is complete Console.WriteLine("Operation complete"); } ``` In this example, the MyMethodAsync method is declared as an asynchronous method using the async keyword. The method starts an asynchronous operation using Task.Run and then waits for the operation to complete using the await keyword. ### Handling Exceptions in Asynchronous Code Handling exceptions in asynchronous code is similar to handling exceptions in synchronous code. However, there are some additional considerations that you need to be aware of. When an exception is thrown in an asynchronous method, it is not caught by the method itself. Instead, the exception is caught by the Task that represents the asynchronous operation. Here is an example of how to handle exceptions in an asynchronous method: ```csharp public async Task MyMethodAsync() { try { // Start an asynchronous operation var task = Task.Run(() => { // Simulate a long-running operation Thread.Sleep(5000); // Throw an exception throw new Exception("Something went wrong"); }); // Wait for the operation to complete await task; } catch (Exception ex) { // Handle the exception Console.WriteLine("Exception caught: " + ex.Message); } } ``` In this example, the MyMethodAsync method catches any exceptions that are thrown by the asynchronous operation and handles them accordingly. ### Cancelling Asynchronous Operations Sometimes, you may need to cancel an asynchronous operation. You can use the CancelationTokenSource class to cancel an asynchronous operation. Here is an example of how to cancel an asynchronous operation: ```csharp public async Task MyMethodAsync() { // Create a cancellation token source var cts = new CancellationTokenSource(); try { // Start an asynchronous operation var task = Task.Run(() => { // Simulate a long-running operation Thread.Sleep(5000); }, cts.Token); // Wait for the operation to complete await task; // Code to execute after the operation is complete Console.WriteLine("Operation complete"); } catch (OperationCanceledException ex) { // Handle the cancelled operation Console.WriteLine("Operation cancelled"); } // Cancel the operation cts.Cancel(); } ``` In this example, the MyMethodAsync method creates a cancellation token source and uses it to cancel the asynchronous operation. ### Lab Exercise For this lab exercise, you will write an asynchronous C# program that uses async/await to handle long-running tasks. **Step 1:** Create a new C# console application project in Visual Studio. **Step 2:** Create a new class called `LongRunningTask` that contains a method called `PerformTaskAsync`. This method should simulate a long-running task using `Thread.Sleep`. **Step 3:** Create a new method called `MainAsync` that uses async/await to call the `PerformTaskAsync` method. **Step 4:** Handle any exceptions that are thrown by the asynchronous operation. **Step 5:** Cancel the asynchronous operation using a CancelationTokenSource. **Step 6:** Run the program and observe the output. Here is an example of what the code might look like: ```csharp public class LongRunningTask { public async Task PerformTaskAsync() { // Simulate a long-running task await Task.Run(() => { Thread.Sleep(5000); }); } } public class Program { public static async Task MainAsync() { var task = new LongRunningTask(); try { // Start the long-running task await task.PerformTaskAsync(); // Code to execute after the task is complete Console.WriteLine("Task complete"); } catch (Exception ex) { // Handle any exceptions Console.WriteLine("Exception caught: " + ex.Message); } // Cancel the task var cts = new CancellationTokenSource(); cts.Cancel(); } } ``` ### Conclusion In this lab exercise, you learned how to write an asynchronous C# program using async/await to handle long-running tasks. You also learned how to handle exceptions and cancel asynchronous operations. ### Comments and Feedback Please leave a comment with any feedback or suggestions on how to improve this lab exercise. If you have any questions or need further clarification on any of the concepts, please don't hesitate to ask. **External Resources** * [Async/Await documentation](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/index) * [Task Parallel Library documentation](https://msdn.microsoft.com/en-us/library/system.threading.tasks(v=vs.110).aspx) * [Cancellation Token Source documentation](https://msdn.microsoft.com/en-us/library/system.threading.cancellationtokensource(v=vs.110).aspx) **Next Topic:** [Introduction to ADO.NET and database operations.](#)

public async Task MyMethodAsync()
{
    // Start an asynchronous operation
    var task = Task.Run(() =>
    {
        // Simulate a long-running operation
        Thread.Sleep(5000);
    });

    // Wait for the operation to complete
    await task;

    // Code to execute after the operation is complete
    Console.WriteLine("Operation complete");
}

public async Task MyMethodAsync()
{
    try
    {
        // Start an asynchronous operation
        var task = Task.Run(() =>
        {
            // Simulate a long-running operation
            Thread.Sleep(5000);

            // Throw an exception
            throw new Exception("Something went wrong");
        });

        // Wait for the operation to complete
        await task;
    }
    catch (Exception ex)
    {
        // Handle the exception
        Console.WriteLine("Exception caught: " + ex.Message);
    }
}

public async Task MyMethodAsync()
{
    // Create a cancellation token source
    var cts = new CancellationTokenSource();

    try
    {
        // Start an asynchronous operation
        var task = Task.Run(() =>
        {
            // Simulate a long-running operation
            Thread.Sleep(5000);
        }, cts.Token);

        // Wait for the operation to complete
        await task;

        // Code to execute after the operation is complete
        Console.WriteLine("Operation complete");
    }
    catch (OperationCanceledException ex)
    {
        // Handle the cancelled operation
        Console.WriteLine("Operation cancelled");
    }

    // Cancel the operation
    cts.Cancel();
}

public class LongRunningTask
{
    public async Task PerformTaskAsync()
    {
        // Simulate a long-running task
        await Task.Run(() =>
        {
            Thread.Sleep(5000);
        });
    }
}

public class Program
{
    public static async Task MainAsync()
    {
        var task = new LongRunningTask();

        try
        {
            // Start the long-running task
            await task.PerformTaskAsync();

            // Code to execute after the task is complete
            Console.WriteLine("Task complete");
        }
        catch (Exception ex)
        {
            // Handle any exceptions
            Console.WriteLine("Exception caught: " + ex.Message);
        }

        // Cancel the task
        var cts = new CancellationTokenSource();
        cts.Cancel();
    }
}