CODEWITHSUNDEEP
c#exceptiontry-catch
jon
jon

Reputation: 321

Can I execute multiple Catch blocks?

This is a bit abstract, but is there any possible way to throw an exception and have it enter multiple catch blocks? For example, if it matches a specific exception followed by a non-specific exception. 

catch(Arithmetic exception)
{
  //do stuff
}
catch(Exception exception)
{
  //do stuff
}

Upvotes: 29

Views: 31884

Answers (6)

keithwill
keithwill

Reputation: 2044

If you were using VB.NET you could abstract your error handler in the Arithmetic exception into a function or method call that always returns false.

Then you could write something like:

Catch ex as Arithmetic When HandleArithmetic()
Catch ex as Exception

End Try

Not that I would advocate such usage, though I have seen it recommended for logging purposes before. I don't believe there is a C# equivalent.

Upvotes: 2

Steve
Steve

Reputation: 8511

This is known as exception filtering and isn't supported in C# (I'm told it is possible in VB.NET).

One work around would be to catch the general exception and then check the exception type in the catch block and do any specific processing on that before carrying on with the rest of the block.

Upvotes: -1

tvanfosson
tvanfosson

Reputation: 532485

No. It isn't possible to execute the code in both catch blocks for a single exception.

I would probably refactor the code in the generic exception block into something that can be called from either.

try
{
   // blah blah blah
{
catch(Arithmetic ae)
{
   HandleArithmeticException( ae );
   HandleGenericException( ae );
}
catch(Exception e)
{
  HandleGenericException( e );
}

Upvotes: 26

Brad Cunningham
Brad Cunningham

Reputation: 6501

Like others said the exception will be caught by the most specific catch block.

This brings up a frustration of mine though with exception handling. I wish you could do something like

catch (ArgumentNullExcpetion, ArugmentOutOfRangeException ex)
{

}

Instead of having to do 

catch (ArgumentNullExcpetion e)
{
}
catch (ArugmentOutOfRangeException outOfRange)
{
}

I understand the reasoning against this that you probably do different things for different exceptions but sometimes I want combine them.

Upvotes: 5

Reed Copsey
Reed Copsey

Reputation: 564433

It is perfectly acceptable to have multiple catch blocks of differring types. However, the behavior is that the first candidate block handles the exception.

It will not enter BOTH catch blocks. The first catch block that matches the exception type will handle that specific exception, and no others, even if it's rethrown in the handler. Any subsequent ones will be skipped once an exception enters a catch block.

In order to have an exception caught in BOTH blocks, you would need to either nest blocks like so:

try
{
     try
     {
        // Do something that throws  ArithmeticException
     }
     catch(ArithmeticException arithException)
     {
        // This handles the thrown exception....

        throw;  // Rethrow so the outer handler sees it too
     }
}
catch (Exception e)
{
   // This gets hit as well, now, since the "inner" block rethrew the exception
}

Alternatively, you could filter in a generic exception handler based on the specific type of exception.

Upvotes: 48

Ryan Lundy
Ryan Lundy

Reputation: 210160

You can't have more than one exception block handle the same exception. But what you can do is catch the general exception, then attempt to cast to the more specific, like this:

catch (Exception exception)
{
    var aex = exception as ArithmeticException
    if (aex != null)
    {
        // do stuff specific to this exception type
    }
  // then do general stuff
}

Upvotes: 2

Related Questions