Jumping out of a finally-block

Question

I'm looking for a keyword or clean way to exit a finally block without using selection statements. Consider the following example:

private bool AtteptToDoSomething()
{
    try
    {
        MethodThatCouldFail();
        return true;
    }
    catch
    {
        return false;
    }
    finally
    {
        //Jump out of function here?            

        //... to avoid executing this under certain conditions
        DoSomethingFinalizing();
    }
}

Attempts that didn't work:

finally
{
    return;
    break;
    continue;
    goto ExitSymbol;
    //This works, but would require a second try-catch block
    throw new Exception();
}

The compiler errors for above examples include:

Control cannot leave the body of a finally clause

and

Cannot jump out of the finally block

It's pretty clear now that a finally block can't transfer control by any regular means.

There is a pretty good explanation why this won't work with continue, but unfortunately not why this can't be done in any other case.

Are there any (CLR or C# based) reasons why this is not allowed/possible?

Are there any exceptions to this restriction except for throw?

Answer 1

You cannot.

It's by design and it's described in a C# specification: 8.10 The try statement.

It is a compile-time error for a break, continue, or goto statement to transfer control out of a finally block. When a break, continue, or goto statement occurs in a finally block, the target of the statement must be within the same finally block, or otherwise a compile-time error occurs.

It is a compile-time error for a return statement to occur in a finally block.

To make what you want you could do something like:

try {}
catch {}
finally
{
    Magic();
}

and then

  void Magic()
  {     
        if (x == y)
           return;
        else
           a = b;    
  }

Answer 2

Well, you can just not execute the block

...
finally
{
    if (!certain conditions) 
    {   
        //... to avoid executing this under certain conditions
        DoSomethingFinalizing();
    }
}

Answer 3

The C# specification indicates the following:

• a finally block cannot contain a break, goto, or continue that would transfer control outside the finally block.
• a finally block cannot contain a return statement.

In short, a finally block must execute to it's last line of code.

Source: https://msdn.microsoft.com/en-us/library/aa664733(v=vs.71).aspx

Also, according to the C# spec, a finally block is always executed after the try block or catch block are executed.

So, if these requirements were not in place, then there could be control flow conflicts with flow statements that occur with the try or catch blocks.

Example 1

try
{
  // do something
  continue;
}
finally
{
  break;
}

In the above case, the try block is indicating that flow should go to the top of the encompassing loop. But the finally block is indicating that the loop should be exited.

Which to do?

Example 2

try
{
  return 0;
}
finally
{
  return 1;
}

Here we have conflicting return values.

Which to return?

The writers of the C# specification could have chosen that the finally block's control flow overrides that of the try or catch block. But that would have complicated things with regard to the compiler and debugging.

Instead, they decided to keep it simple and avoid it completely by forbidding flow control out of the finally block.

Answer 4

I know this is an old question but I stumbled upon the same situation but in PHP. I wasn't able to jump out of a finally block

PHP Fatal error: jump out of a finally block is disallowed

And because you and I my friend are curious souls in the realm of computer science, I posted this answer hoping that it will satisfy your curiosity.

Why it's not possible to jump out of a finally block?

Simply put, because finally does not guarantee that the exception is handled.

Finally block will always be executed whether the exception is handled or not, so if you're trying to jump out of a finally block that means you want to do more, and doing more here is like you're trying to access or deal with something that is not guaranteed to be existed (so it doesn't make sense).

Answer 5

You could do it by placing your label at the end of the finally block, like so:

try
{
    ...
}
finally
{
    if (condition) goto ExitFinally;
    ...
    ExitFinally:
}