Using Lamda's and Generics to encapsulate a Try-Catch-Finally block

I recently had a legacy (.NET 2.0) project that I was asked to bring up to date with .NET 4.5.  In the process I came across numerous functions that followed the same format wrapping their functionality in a try-catch-finally code block or some variant (try-catch or try-finally).

This is a normal process in many apps, of course, but in many of these cases the catch and finally logic were duplicated.  The more I worked with it, the more I felt like there had to be a way to create a re-usable function to handle it for me.  What I came up with works pretty darn well, though it does make the code a little more complicated.

Code Snippet

101. public static TResult TryCatch<TParam1, TResult, TException>(this Func<TParam1[], TResult> executeFunc, Func<TException, TResult> errorAction = null, Action<TParam1[]> finalAction = null, params TParam1[] args) where TException : Exception
102. {
103.     if (executeFunc == null)
104.         throw new ArgumentNullException("executeFunc");
105.  
106.     try
107.     {
108.         return executeFunc.Invoke(args);
109.     }
110.     catch (TException ex)
111.     {
112.         if (errorAction != null)
113.             return errorAction.Invoke(ex);
114.     }
115.     finally
116.     {
117.         if (finalAction != null)
118.             finalAction.Invoke(args);
119.     }
120.     throw new ArgumentException("No return value specified");
121. }

As you can see the function takes a variety of inputs to handle the guts of the code itself as well as the catch and finally blocks. The key parts of this function are:

1. TParam1 - The type of parameter object
2. TResult - The type of the return object
3. TException - The type of exception expected to be caught
4. executeFunc - The function to execute in the try block
5. errorAction - An action to perform if an exception of the given type is caught
6. finalAction - An action to perform on Finally
7. args - An array of arguments passed to the executeFunc (if any)

Code Snippet

10. [Test]
11. public void TryCatch_Test()
12. {
13.     var callback = false;
14.  
15.     Func<object[], bool> func = x =>
16.         {
17.             callback = true;
18.             return true;
19.         };
20.     Func<Exception, bool> showError = exception => false;
21.  
22.     var result = func.TryCatch(showError);
23.  
24.     Assert.That(result, Is.True);
25.     Assert.That(callback, Is.True);
26. }
27.  
28. [Test]
29. public void TryCatch_Exception_Test()
30. {
31.     var callback = false;
32.  
33.     Func<object[], bool> func = x => { throw new Exception("Test Exception"); };
34.  
35.     Func<Exception, bool> showError = exception =>
36.         {
37.             callback = true;
38.             return false;
39.         };
40.  
41.     var result = func.TryCatch(showError);
42.  
43.     Assert.That(result, Is.False);
44.     Assert.That(callback, Is.True);
45. }
46.  
47. [Test]
48. public void TryCatch_DifferentType_Test()
49. {
50.     var callback = false;
51.     var finalCallback = false;
52.  
53.     Func<int[], int> func = ints =>
54.         {
55.             callback = true;
56.             return ints.Sum();
57.         };
58.     Func<Exception, int> showError = exception => 0;
59.     Action<int[]> final = ints => { finalCallback = true; };
60.  
61.     var result = func.TryCatch(showError, final, 2, 5, 8);
62.  
63.     Assert.That(result, Is.EqualTo(15));
64.     Assert.That(callback, Is.True);
65.     Assert.That(finalCallback, Is.True);
66. }

I included these three unit tests as I felt like they displayed the uses of this function quite nicely.

This code creates a nice re-usable function that gives us some real power and flexibility. No need to wrap your functions into a try-catch block. And since its an extension method you can write your Func and then tack the .TryCatch() call to the end.