Why finally?

[Ken]

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

[Jon Skeet]

Ken <kr****@fnis.co m> wrote:

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

The difference is when an exception *isn't* caught, but is propagated
up the stack, or when the catch block terminates the method (returns or
throws an exception itself). This doesn't happen in your case, because
you're catching Exception (well, I suppose it will happen if some non-
CLS compliant exception, or an uncatchable exception, is thrown).

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet/
If replying to the group, please do not mail me too

[Jay B. Harlow [MVP - Outlook]]

Ken,
Consider the following:

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
} catch (ApplicationExc eption e) {
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
Where I only want to catch ApplicationExce ptions, other kind of exceptions
will be handled outside of this routine.

For any kind of exception Application or otherwise I want the finally to be
executed.

Also finally is useful if you want to catch the exception, log it, then
rethrow the exception so others can deal with it.

catch (Exception ex)
{
ExceptionHandle r(ex); // logs the exception
throw; // (re) throws the caught exception
}
finally
{
// do clean up here
}

Hope this helps
Jay

"Ken" <kr****@fnis.co m> wrote in message
news:01******** *************** *****@phx.gbl.. . What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

[EMonaco]

Ken,

Having a finally block ensures that the code inside of it will always be
executed before the function is exited.

example:

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
// if you do not have an exception return
return; // normally this would exit the function, however because
finally{} that code will be executed as well.
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
throw e; // this would cause function exit too- with finally{} that
code will be executed!
}
finally
{
Console.Write(" i = {0}", i);
}
}

finally{} is a great place to put resource clean up code- ensuring that it
always gets executed before returning!
Examples are things such as .Close() of streams, messaging, signalling, etc.
As most importantly, if you work with critical sections, mutex's etc. You
should put that release of those objects in a finally{} to ensure that they
are released so you don't encounter a deadlock, or resource indefinitely
locked issues.
Erin.

"Ken" <kr****@fnis.co m> wrote in message
news:01******** *************** *****@phx.gbl.. .

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

[Andre]

Lots of reasons.. imagine you have a number of Catch()'s.. different
ones that catch different type of exceptions. One that catches an
IOException and one that catches a MalNumberformat or whatever. Suppose
the MalNumberFormat exception might occur at the very start of the
method and the IOException might occur near the end of the method. Also
suppose that you already have a file opened or a scarse resource in use
*before* the line where a NumberFormat exception can be thrown. Now if
your program at runtime encounters a NumberFormat exception, you might
end up with that scarce resource un-closed because it wasn't normally
closed after being used after the lines in the method that make use of
it (which are near the end of the method). Now also suppose that the
Catch(NumberFor matException) block deals with this problem a little
differently, in that, it 'retries' the method by jumping over to a label
in the method to the line where the exception was thrown, just to give
it another try... it would then not be wise to close the file in this
catch block. Similarly, after triend a couple of times, you might want
to jump off to another part of the code in the catch block and might not
ever release the file or the resource. 'finally' gives you the
assurances that the peice of code inside 'finally' will always be called
and so you can safely release your resources and close them 'properly'
in whatever manner you wish. Finally has a number of other similar uses.
Hope that clears a bit...
-Andre

Ken wrote:

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

[tribal]

When an error is generated the runtime checks to see if
there is a finally block and if one is found then it is
executed. Any other code after finally will not be reached
as an error was generated and it is to be dealt with

The finally block is executed even if there is no error
This is helpful for code cleanup example to close file
references etc.. as it is always guaranteed to be executed
hope this helps

regards

tribal

-----Original Message-----
What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentatio n. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should stillexecute since it comes after the whole thing.

So... what is the difference between a "finally" block andnothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int
i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

.

[Ken]

Thanks! This is the difference I was looking for. The
documentation did not make it clear to me that a finally
block was executed even if the "catch" block exited the
function. Now I can clearly see their benefit.

-----Original Message-----
Ken,
Consider the following:

try
{
// Invalid conversion; o contains a string not an int i = (int) o;
} catch (ApplicationExc eption e)

{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}

Where I only want to catch ApplicationExce ptions, other

kind of exceptionswill be handled outside of this routine.

For any kind of exception Application or otherwise I want the finally to beexecuted.

Also finally is useful if you want to catch the exception, log it, thenrethrow the exception so others can deal with it.

catch (Exception ex)
{
ExceptionHandle r(ex); // logs the exception
throw; // (re) throws the caught exception
}
finally
{
// do clean up here
}

Hope this helps
Jay

"Ken" <kr****@fnis.co m> wrote in message
news:01******* *************** ******@phx.gbl. ..

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still execute since it comes after the whole thing.

So... what is the difference between a "finally" block and nothing at all?

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}
finally
{
Console.Write(" i = {0}", i);
}
}

Now, consider something similar:

void foo()
{
int i = 123;
string s = "Some string";
object o = s;

try
{
// Invalid conversion; o contains a string not an int i = (int) o;
}
catch (Exception e)
{
Console.WriteLi ne("Exception!" );
}

Console.Write(" i = {0}", i);
}

.

[james]

Jon, you cannot return from a try catch finally block. You will get an
error

JIM

"Jon Skeet" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@news.microsof t.com...

Ken <kr****@fnis.co m> wrote:

What is the purpose of a finally block in try-catch-
finally? I am confused because, if I am reading the
definition correctly, this block seems unnecessary.
Consider the following from the Visual Studio
documentation. In the first foo(), the statement in the
finally block will execute even though there is an
exception in the try block. In the second foo(), I took
the statement out of the finally block but it should still
execute since it comes after the whole thing.

So... what is the difference between a "finally" block and
nothing at all?

The difference is when an exception *isn't* caught, but is propagated
up the stack, or when the catch block terminates the method (returns or
throws an exception itself). This doesn't happen in your case, because
you're catching Exception (well, I suppose it will happen if some non-
CLS compliant exception, or an uncatchable exception, is thrown).

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet/
If replying to the group, please do not mail me too

[Jon Skeet]

james <no****@hyperco n.net> wrote:

Jon, you cannot return from a try catch finally block. You will get an
error

You can't return from a finally block, but you can most definitely
return from try and catch blocks:

using System;

public class Test
{

static void Main()
{
string x = ReturnFromTry() ;
Console.WriteLi ne (x);
x = ReturnFromCatch ();
Console.WriteLi ne (x);
}

static string ReturnFromTry()
{
try
{
return "try";
}
catch
{
}
finally
{
Console.WriteLi ne ("Finally");
}
return "Oops";
}

static string ReturnFromCatch ()
{
try
{
throw new Exception();
}
catch
{
return "catch";
}
finally
{
Console.WriteLi ne ("Finally");
}
}
}

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet/
If replying to the group, please do not mail me too

[james]

Yep, I guess I misread, I was thinking of return from finally.
Which by the way is kind of a pain not being able to do that.
JIM

"Jon Skeet" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@news.microsof t.com...

james <no****@hyperco n.net> wrote:

Jon, you cannot return from a try catch finally block. You will get an
error

You can't return from a finally block, but you can most definitely
return from try and catch blocks:

using System;

public class Test
{

static void Main()
{
string x = ReturnFromTry() ;
Console.WriteLi ne (x);
x = ReturnFromCatch ();
Console.WriteLi ne (x);
}

static string ReturnFromTry()
{
try
{
return "try";
}
catch
{
}
finally
{
Console.WriteLi ne ("Finally");
}
return "Oops";
}

static string ReturnFromCatch ()
{
try
{
throw new Exception();
}
catch
{
return "catch";
}
finally
{
Console.WriteLi ne ("Finally");
}
}
}

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet/
If replying to the group, please do not mail me too