USING clause with TRY...CATCH blocks

  • Thread starter Thread starter Guest
  • Start date Start date
G

Guest

Consider the following, where Foo implements IDisposable:

try
{
using (Foo myFoo = new Foo())
{
myFoo.Execute();
}
}
catch (someException)
{
// some stuff
}
finally
{
// some other stuff
}

If the call to Foo.Execute() throws an exception, is Foo displosed? My
understanding is that it would be if the TRY...CATCH is inside the USING, but
what happens in the example given above?

Thanks in advance.

/Joel Finkel
 
Joel,
If the call to Foo.Execute() throws an exception, is Foo displosed?
Click to expand...

Do you mean is myFoo disposed? If so the answer is yes, even without
the outer try/catch block. That's the whole point of the using
statement.


Mattias
 
Thank you. I wanted to ensure that the code did not branch around the
implicit Dispose by jumping directly to the exception handling.
 
Hi Joel,

a little "behind-the-scenes" might further clarify this: the C#-compiler
translates your using-block into a try-finally block containing the original
statements inside the using block, so

using (Foo myFoo = new Foo())
{
myFoo.Execute();
}

becomes:
try
{
myFoo.Execute();
}
finally
{
myFoo.Dispose();
}

If an exception should occur within the statements originally within the
using-block, this exception will bubble up, but only after running the
finally-section disposing your object.

HTH,
Baileys
 
Hi Joel,

a little "behind-the-scenes" might further clarify this: the C#-compiler
translates your using-block into a try-finally block containing the original
statements inside the using block
Click to expand...

With this in mind, I'm surprised that 'using' is preferred over
try/finally. Yes, it looks simpler for opening one file...IF the file
open or subsequent ops are guaranteed not to generate an exception.
But if an exception is generated, isn't it better to have explicit
handlers in the finally block?

Also multiple file opens seem more awkward with 'using' statements.
I know that you could add multiple opens to one 'using' but I'm not
sure if the exact handling if, say, file #3 out of 5 generates an
exception. I would imagine that the compiler generates code that
knows to close/dispose just the first two files. But perhaps for that
reason, I've seen experts write nested 'using' blocks. Not pretty.

Couldn't the mutiple opens be more gracefully handled in a try-finally
block?
 
_DS said:
With this in mind, I'm surprised that 'using' is preferred over
try/finally. Yes, it looks simpler for opening one file...IF the file
open or subsequent ops are guaranteed not to generate an exception.
But if an exception is generated, isn't it better to have explicit
handlers in the finally block?
Click to expand...

Not unless you want to do something other than calling Dispose on the
stream.
Also multiple file opens seem more awkward with 'using' statements.
I know that you could add multiple opens to one 'using' but I'm not
sure if the exact handling if, say, file #3 out of 5 generates an
exception. I would imagine that the compiler generates code that
knows to close/dispose just the first two files. But perhaps for that
reason, I've seen experts write nested 'using' blocks. Not pretty.
Click to expand...

I generally use nested using blocks, although you can nest without
having extra braces:

using (...)
using (...)
{
code
}
Couldn't the mutiple opens be more gracefully handled in a try-finally
block?
Click to expand...

Which do you think is simpler:

Stream first = null;
Stream second = null;
try
{
first = new FileStream (...);
second = new FileStream (...);
// Code
}
finally
{
if (first != null)
{
first.Dispose();
}
if (second != null)
{
second.Dispose();
}
}

or:

using (Stream first = new FileStream (...))
using (Stream second = new FileStream(...))
{
// Code
}

I know which I prefer...

Jon
 
Back
Top