C# 4 and .NET 4

Catching exceptions ❘ 361
{
// error handling
}
finally
{
// clean up
}
Although each try block is accompanied by only one catch block in this example, you could string several
catch blocks together, too. This section takes a closer look at how nested try blocks work.
If an exception is thrown inside the outer try block but outside the inner try block (points A and D), the
situation is no different from any of the scenarios you have seen before: either the exception is caught by the
outer catch block and the outer finally block is executed, or the finally block is executed and the .NET
runtime handles the exception.
If an exception is thrown in the inner try block (point B), and there is a suitable inner catch block to
handle the exception, then, again, you are in familiar territory: the exception is handled there, and the inner
finally block is executed before execution resumes inside the outer try block (at point D).
Now suppose that an exception occurs in the inner try block, but there isn ’ t a suitable inner catch block to
handle it. This time, the inner finally block is executed as usual, but then the .NET runtime will have no
choice but to leave the entire inner try block to search for a suitable exception handler. The next obvious
place to look is in the outer catch block. If the system fi nds one here, then that handler will be executed and
then the outer finally block will be executed. If there is no suitable handler here, the search for one will
go on. In this case, it means the outer finally block will be executed, and then, because there are no more
catch blocks, control will be transferred to the .NET runtime. Note that the code beyond point D in the
outer try block is not executed at any point.
An even more interesting thing happens if an exception is thrown at point C. If the program is at point C, it
must be already processing an exception that was thrown at point B. It is quite legitimate to throw another
exception from inside a catch block. In this case, the exception is treated as if it had been thrown by the
outer try block, so fl ow of execution will immediately leave the inner catch block, and execute the inner
finally block, before the system searches the outer catch block for a handler. Similarly, if an exception is
thrown in the inner finally block, control will immediately be transferred to the best appropriate handler,
with the search starting at the outer catch block.
It is perfectly legitimate to throw exceptions from catch and finally blocks.
Although the situation has been shown with just two try blocks, the same principles hold no matter
how many try blocks you nest inside each other. At each stage, the .NET runtime will smoothly
transfer control up through the try blocks, looking for an appropriate handler. At each stage, as
control leaves a catch block, any cleanup code in the corresponding finally block (if present) will be
executed, but no code outside any finally block will be run until the correct catch handler has been
found and run.
The nesting of try blocks can also occur between methods themselves. For example, if method A calls
method B from within a try block, then method B itself has a try block within it as well.
You have now seen how having nested try blocks can work. The obvious next question is why would you
want to do that There are two reasons:
➤
➤
To modify the type of exception thrown
To enable different types of exception to be handled in different places in your code
www.it-ebooks.info