Try Catch block

Question

I have the following code

Try
    'Some code that causes exception
Catch ex as ExceptionType1
    'Handle Section - 1
Catch ex as ExceptionType2
    'Handle section - 2
Catch ex as ExceptionType3
    'Handle section - 3    
Finally
    ' Clean up
End Try

Suppose ExceptionType1 is thrown by the code which is handled by section - 1. After handling that in section-1, can I have control passed to section-2/section-3? Is that possible?

Answer 1

change the code to catch all the exception in one block and determine the type and execution path from there.

Answer 2

I think you could get the behavior you want if you do nested try blocks. Once an exception is thrown, execution goes to the catch block. If nothing is rethrown, it moves on to finally.

Answer 3

You could call functions in the exception handlers.

Try
'Some code that causes exception'
Catch ex as ExceptionType1
  handler_1()
  handler_2()
  handler_3()
Catch ex as ExceptionType2
  handler_2()
  handler_3()
Catch ex as ExceptionType3
  handler_3()
Finally
  handler_4()    
End Try

Answer 4

You haven't specified a language, and i don't know the language, so i answer generally.

You can't do that. If you want to have common code, put that either into finally, or if it only needs to be executed for some catching cases, you can copy that code into the respective cases. If the code is bigger and you want to avoid redundancy, you can put it into a function of its own. If that would reduce the readability of your code, you can nest your try/catch blocks (at least in Java and C++. I don't know about your language). Here is an example in Java:

class ThrowingException {
    public static void main(String... args) {
        try {
            try {
                throw new RuntimeException();
            } catch(RuntimeException e) {
                System.out.println("Hi 1, handling RuntimeException..");
                throw e;
            } finally {
                System.out.println("finally 1");
            }
        } catch(Exception e) {
            System.out.println("Hi 2, handling Exception..");
        } finally {
            System.out.println("finally 2");
        }
    }
}

This will print out:

Hi 1, handling RuntimeException..
finally 1
Hi 2, handling Exception..
finally 2

put your common code into the outer catch block. Doing it using the nested version also handles cases where an exception occurs without you explicitly re-throwing the old in a catch block. It may fit to what you want even better, but it may also not.