How to Use Await and Async Keywords Within Catch and Finally Block in C# 6.0

Introduction

Traditionally await and asynch have been used in threading and multithreading programming. Until C# version 5.0 we used try, catch and finally together but await and asynch was not used with catch and finally. Now the latest released by Microsoft enables the programmer to use await and asynch in the catch block and in the finally block as well.

Working of try , catch and finally blocks is given below:

This section can be understood by analyzing a simple code in which an error is generated by the compiler handled by the try and catch block.

Now in the code above we can see that the code above throws an exception of the type "DivideByZeroException" .
 
Now the the following code uses a try, catch and finally block to handle an exception generated by the code above and now it can be understood using the code shown below. 

namespace ConsoleApplication4

{
    class Example
    {
        static int z;
        public static void Main(String[] args)
        {
            int a = 10;
            int b = 0;
            try
            {
                z = a / b;
            }
            catch (Exception e)
            {
                Console.WriteLine("the value of z is " + z);
            }
            finally
            {
                Console.WriteLine("above the value of z printed is its default value");
            }

            System.Console.ReadKey();
        }
    }
}

await and async keywords

These keywords simplify the code necessary to make asynchronous calls. Within the mechanization the compiler manages the complexity whilst the code remains relatively simple. A programmer might get the benefits of this new functionality merely by marking methods using the new keyword "async". These two were introduced first in C# version 5.0 and now the functionality has been enhanced in the new version 6.0 of the C# language.

The async keyword marks a method for the compiler. The await keyword signals the code to wait for the return of a long-running operation.

Async calls return  immediately, leaving the main thread responsive while the longer running process is forced to run in the background. Use of void returning methods is suitable only for specific situations in which the actions completed by the thread are no longer a concern of the main thread.

"void" returning methods are suitable for the launch and forget about it sort of scenario. Methods returning Task are similar to void in as much as those methods do not return a value to the calling method either. If data is to be returned to the main thread and handled there, one should use a return type of Task<T>.

Error handling within methods using the three return types is also different. Similarly, Task return type methods should also handle their own errors. Error handling now becomes more suitable and reliable for methods returning Task<T> might be accomplished within the calling thread.

The following is a program to illustrate the use of the await and async keywords within the catch block.

program.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private async void button1_Click(object sender, EventArgs e)
        {
            Task<string> theTask = DelayAsync();

            try
            {
                string result = await theTask;
                Debug.WriteLine("Result: " + result);
            }
            catch (Exception ex)
            {
                Debug.WriteLine("Exception Message: " + ex.Message);
                label1.Text = "Exception Message: " + ex.Message;
            }
            Debug.WriteLine("Task IsCanceled: " + theTask.IsCanceled);
            Debug.WriteLine("Task IsFaulted:  " + theTask.IsFaulted);
            if (theTask.Exception != null)
            {
                Debug.WriteLine("Task Exception Message: "
                    + theTask.Exception.Message);
                Debug.WriteLine("Task Inner Exception Message: "
                    + theTask.Exception.InnerException.Message);
            }
        }//

        private async Task<string> DelayAsync()
        {
            await Task.Delay(100);

program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}

Output



 After clicking the button we will get the error message after the exception is caught.



Summary

In this article we learned how to use the async and await keywords with the catch and finally blocks. These are the most convenient way to use these keywords that really helps programmers. Although these things remains simple and of course the complexity is removed by Microsoft.