Exception Handling in C# Asynchronous Programming

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading;  
using System.Threading.Tasks;  
namespace Asynchronious  
{  
    class Test  
    {  
        public Task ShowAsync()  
        {  
            return Task.Run(()=>{  
                Task.Delay(2000);  
                throw new Exception("My Own Exception");  
            });  
        }  
        public async void Call()  
        {  
            await ShowAsync();  
        }  
    }   
    class Program  
    {  
        public static void Main(String [] args)  
        {  
            Test t = new Test();  
            try  
            {  
                t.Call();  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine(ex.Message);  
            }  
            Console.ReadLine();  
        }  
    }  
}

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading;  
using System.Threading.Tasks;  
namespace Asynchronious  
{  
    class Test  
    {  
        public Task ShowAsync()  
        {  
                return Task.Run(() =>  
                {  
                    try  
                    {  
                        Task.Delay(2000);  
                        throw new Exception("My Own Exception");  
                    }  
                    catch (Exception ex)  
                    {  
                        Console.WriteLine(ex.Message);  
                        return null;  
                    }  
                });  
        }  
        public async void Call()  
        {  
            try  
            {  
                await ShowAsync();  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine(ex.Message);  
            }  
        }  
    }   
    class Program  
    {  
        public static void Main(String [] args)  
        {  
            Test t = new Test();  
            t.Call();  
            Console.ReadLine();  
        }  
    }  
}

Now, you may wonder: We have implemented a try-catch block within Task and it's fine, but what need is there for implementing a try-catch within the Call() function? The reason is because when an asynchronous function fails to execute a Task, it throws a Task Cancelled exception. We need to implement a mechanism to catch this exception.

Here is the output screen:

We see that now the Exception Handling block is capable of catching the exception.

Now the question is: is it possible to wrap a try-catch block over an asynchronous function as is done for traditional synchronous functions? The answer is that we can, but with a limitation. What is the limitation? The exception should occur outside of the Task process statement. Then the Exception Handling block can catch the exception. Let's see the following example:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading;  
using System.Threading.Tasks;  
namespace Asynchronious  
{  
    class Test  
    {  
        public Task ShowAsync()  
        {  
            throw new Exception("My Own Exception");  
            return Task.Run(() =>  
                {  
                    Task.Delay(2000);  
                });              
        }  
        public async void Call()  
        {  
            try  
            {  
               await ShowAsync();  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine(ex.Message);  
            }  
        }  
    }   
    class Program  
    {  
        public static void Main(String [] args)  
        {  
            Test t = new Test();  
            t.Call();  
            Console.ReadLine();  
        }  
    }  
} 

Here the exception occurs outside of the Task, now the exception is caught by the try catch block from the calling location. Here is the sample output:

Conclusion

This article has explained Exception Handling in asynchronous programming. I hope you have understood it. In the next article, I would like to discuss a few more real-world examples of asynchronous programming.

Next Article >> Asynchronous Programming in C# 5.0: Part Five: Access Data Sing Asynchronous Function