Uniform handling of many exceptions

Question

In my current project, i am interacting with some 3rd party middleware that throws many different types of exceptions (around 10 exceptions or more).

My library that is using the 3rd party has a few methods, each one interacts with the 3rd party, however needs to be protected from the same set of 10 or more exceptions.

What i currently have is something like this in every method of my library:

try
{
   // some code
}
catch (Exception1 e)
{
}
catch (Exception2 e2)
{
}
  ...
catch (ExceptionN eN)
{
}

The number of exceptions may increase as well.

How can i reduce the code duplication and uniformly handle all exceptions in a single place?

• suppose that the handling in each method in my code is the same.

Answer 1

I would start by catching the base Exception type and then filtering with a white-list:

try
{
   // Code that might throw.
}
catch (Exception e)
{
    if(e is Exception1 || e is Exception2 || e is ExceptionN) 
    {
         // Common handling code here.
    }
    else throw; // Can't handle, rethrow.
}

Now if you want to generalize the filter, you can write an extension:

public static bool IsMyCustomException(this Exception e)
{
    return e is Exception1 || e is Exception2 || e is ExceptionN;
}

and then you can just use:

if(e.IsMyCustomException())
{
    // Common handling code here.
}
else throw;

You can generalize the handler with a simple method:

private void HandleCustomException(Exception e)
{
    // Common handling code here.
}

If you want to generalize the entire try-catch block, you're probably best off injecting a delegate into a method that wraps the operation, as mentioned by @vc 74.

Answer 2

You can either use a global exception handler, the implementation depends on your project type (ASP.net -> global.asax, WPF -> App.xaml...)

Or use something like the following :

private static void HandleExceptions(Action action)
{
    try
    {
       action();
    }
    catch (Exception1 e)
    {
    }
    catch (Exception2 e2)
    {
    }
      ...
    catch (ExceptionN eN)
    {
    }
}

which can be invoked the following way:

HandleExceptions(() => Console.WriteLine("Hi there!"));

If an exception was thrown during the Console.WriteLine execution, it would then be handled by your exception handling logic

Note that the code to execute might also modify external values:

int x = 2;
HandleExceptions(() => x = 2 * x);

If you prefer anonymous methods:

var x = 2;
HandleExceptions(delegate()
{
  x = x * 2;
});