\r\npublic static void TryCatchBlockWrongWay()\r\n{\r\n try\r\n {\r\n Task.Factory.StartNew(() => { throw new Exception(\"From method TryCatchBlockWrongWay\"); });\r\n }\r\n catch (Exception ex)\r\n {\r\n \/\/ this will never be hit\r\n Console.WriteLine(\"Exception handled {0}\", ex);\r\n }\r\n}\r\n<\/pre>\nIn that case catch block is unreachable (I will describe later what happens with that exception), of course we could use try catch<\/i> inside Task.Factory.StartNew<\/i> lambda expression but this is not always the case. Usually we want to handle exception in the caller of the Task<\/i>, not inside the Task<\/i> itself. There are couple of ways of achieving that – depending on the situation you can use one of the following ways. Exception are propagated to caller once you start waiting for the result of Task<\/i>. So basically you can use try catch<\/i> block if you wait for a Task<\/i> to finish – either by accessing Result<\/i> property or using Wait<\/i> method<\/p>\n\r\npublic static void HandleExceptionTryCatchResult()\r\n{\r\n try\r\n {\r\n var task = Task.Factory.StartNew(() =>\r\n {\r\n throw new Exception(\"From method HandleExceptionTryCatchResult\");\r\n return 1;\r\n });\r\n \/\/ do more stuff while task is running\r\n \/\/ do more stuff while task is running\r\n \/\/ do more stuff while task is running\r\n var result = task.Result;\r\n }\r\n catch (Exception ex)\r\n {\r\n Console.WriteLine(\"HandleExceptionTryCatchResult: exception handled in try catch block. Exception is {0}\", ex);\r\n }\r\n}\r\n\r\npublic static void HandleExceptionTryCatchWait()\r\n{\r\n try\r\n {\r\n var task = Task.Factory.StartNew(() => { throw new Exception(\"From method HandleExceptionTryCatchWait\"); });\r\n \/\/ do more stuff while task is running\r\n \/\/ do more stuff while task is running\r\n \/\/ do more stuff while task is running\r\n task.Wait();\r\n }\r\n catch (Exception ex)\r\n {\r\n Console.WriteLine(\"HandleExceptionTryCatchWait: exception handled in try catch block. Exception is {0}\", ex);\r\n }\r\n}\r\n<\/pre>\nHowever accessing Result<\/i> or calling Wait<\/i> method are blocking calls, so this might not be a perfect solution for every scenario. Fortunately we can also leverage ContinueWith<\/i> method which gives you an ability to specify what should be done once Task<\/i> finishes processing the operation. What is more important you can configure this method to only be called if exception occurs. Nonetheless there is one crucial thing you have to remember – in order to make exception handled or observed you have to access Exception<\/i> property of Task<\/i>…<\/p>\n\r\npublic static void HandleExceptionContinueWith()\r\n{\r\n Task.Factory.StartNew(() => { throw new Exception(\"From method HandleExceptionContinueWith\"); })\r\n .ContinueWith(val =>\r\n {\r\n \/\/ we need to access val.Exception property otherwise unobserved exception will be thrown\r\n \/\/ ReSharper disable once PossibleNullReferenceException\r\n foreach (var ex in val.Exception.Flatten().InnerExceptions)\r\n {\r\n Console.WriteLine(\"HandleExceptionContinueWith: exception handled in ContinueWith. Exception is {0}\", ex);\r\n }\r\n }, TaskContinuationOptions.OnlyOnFaulted);\r\n}\r\n<\/pre>\nor call Handle<\/i> method from AggregateException<\/i> object<\/p>\n\r\npublic static void HandleExceptionContinueWithAndHandleMethod()\r\n{\r\n Task.Factory.StartNew(() => { throw new Exception(\"From method HandleExceptionContinueWith\"); })\r\n .ContinueWith(val =>\r\n {\r\n val.Exception.Handle(ex =>\r\n {\r\n Console.WriteLine(\"HandleExceptionContinueWith: exception handled in AggregateException.Handle. Exception is {0}\", ex);\r\n return true;\r\n });\r\n }, TaskContinuationOptions.OnlyOnFaulted);\r\n}\r\n<\/pre>\nOtherwise exception will not be handled which may cause a lot of troubles described in section 3 of this post. Lastly if you use .NET 4.5<\/i> you can also just use async await<\/i> and try catch<\/i> block<\/p>\n\r\n\/\/ called from Main\r\npublic static async void HandleExceptionTryCatchAwait()\r\n{\r\n try\r\n {\r\n await HandleExceptionTryCatchAwaitInternal();\r\n }\r\n catch (Exception ex)\r\n {\r\n Console.WriteLine(\"HandleExceptionTryCatchAwait: exception handled in try catch block\");\r\n }\r\n}\r\n\r\nprivate static async Task HandleExceptionTryCatchAwaitInternal()\r\n{\r\n return await Task.Factory.StartNew(() =>\r\n {\r\n throw new Exception();\r\n return 1;\r\n }, TaskCreationOptions.LongRunning);\r\n}\r\n<\/pre>\n3. Handling UnobservedTaskException<\/h3>\n
If it happens that exception thrown by Task<\/i> is not handled, once the Task<\/i> is garbage-collected, finalizer thread will throw UnobservedTaskException<\/i>.<\/p>\n\r\nTask.Factory.StartNew(() => { throw new Exception(\"fire-and-forget no exception handling\"); });\r\nusing (var autoresetEvent = new AutoResetEvent(false))\r\n{\r\n \/\/wait for task to run\r\n autoresetEvent.WaitOne(TimeSpan.FromSeconds(2));\r\n}\r\n\r\nConsole.WriteLine(\"GC: Collecting\");\r\nGC.Collect();\r\nGC.WaitForPendingFinalizers();\r\nConsole.WriteLine(\"GC: Collected\");\r\n<\/pre>\nThe implication of this depends on framework we are running our application on. If you run your app on .NET 4.5<\/i> or later version, with default escalation policy, TaskScheduler.UnobservedTaskException<\/i> event will be raised and basically that is all. No more further problems, so basically you may not even realize that there is something like UnobservedTaskException<\/i>. However if we add this entry<\/p>\n\r\n\r\n \r\n<\/runtime>\r\n<\/pre>\n
![\"UnobservedTaskExceptionis\"](\"http:\/\/tpodolak.com\/blog\/wp-content\/uploads\/2015\/08\/tpl-exception-handling-and-unobservedtaskexception-issue\/ProcessKilled.png\")
<\/a>