How many statements in a try/catch statement?

Question

Should I put multiple statements in a try and then catch all possible exceptions, or should I put only one statement in the try statement?

Example:

try {
    MaybeThrowIOException();
    MaybeThrowFooBarException();
    return true;
} catch (IOException e) {
    // ...
} catch (FooBarException e) {
   // ... 
}

Or

try {
    MaybeThrowIOException();
} catch (IOException e) {
    // ...
}

try {
    MaybeThrowFooBarException();
} catch (FooBarException e) {
   // ... 
}

return true;

Answer 1

If they are truly separate like that, then the first is better practice, simply because it's shorter.

However, if it's possible for MaybeThrowIOException() to throw a FooBarException, or for MaybeThrowFooBarException() to throw a IOException, then you should only wrap them together if you want them both to take the same action upon an exception!

Answer 2

If the method you are calling can return FooExeption() and BarException() and you want to catch both, then the first example make the most sense - quite a few API's do this, particularly ones that are higher level (as they themselves are using more things which can raise exceptions).

If you are doing two separate things then it really entirely depends on what you want the outcome to be:

• If an exception in either ultimately amount to the same thing as far as your code is concerned, and you don't care about having roll anything back (or it's simple to roll back from either and you can easily do it in a single finally block - assuming the language supports this) then there is no point in having two separate try/catch blocks.

• If the error types are very varied and you care what happens if the first method raises an exception (e.g. and need to do some operations to roll back) and you want to continue executing the second operation, even if the first one threw an exception, then the second approach would be more appropriate.

• If you care if the first method fails and you don't want to continue executing if it does, then it's worth remembering that you can nest try/catch, though it's best not to go overboard with this. If used well it's much clearer than trying to follow bools in if statements to check if a block should execute or not.

e.g.

try {

    MaybeThrowFooException();

    try {
    // Will only be called as long as MaybeThrowFooException() is not thrown
        MaybeThrowBarException();

    } catch (BarException ex) {

    }

} catch (FooException ex) {

}

Answer 3

you can use any of them.

but if using the first then you should catch the more specific exceptions.

Answer 4

The first choice, it allows more understandable and readable code, more so your procedure or function should be trying to do a very specific action, the fact that you have 2 separate calls that might throw 2 separate exceptions means its doing more than it supposed to, maybe this is necessary

Either spit the 2 calls into 2 separate methods or go with the first approach.

The only reason you might want to go with the second approach is if your method does 2 actions and a little bit more, but you only want to handle 2 lines of code for exceptions, and maybe wrap them and continue executing but this isn't advised

Answer 5

Normally you can separate what you are trying to do into a specific task. Put the code related to that task into one try catch and then if something goes wrong you know that task has failed and you can try to recover from there.

i find this method reduces the amount of catch code you need to write and keeps related logic together.

Answer 6

I would prefer using multiple statements in a try block and then catch all possible exceptions. Not sure why but I always do that while coding