Where should I catch exceptions when making use of '"using" keyword in the code?

Question

Which one is better in structure?

class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (Foo f = new Foo())
            {
                //some commands that potentially produce exceptions.
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

or...

class Program
{
    static void Main(string[] args)
    {

        using (Foo f = new Foo())
        {
            try
            {
                //some commands that potentially produce exceptions.
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

    }
}

Answer 1

Check this post to understand better : http://www.ruchitsurati.net/index.php/2010/07/28/understanding-%E2%80%98using%E2%80%99-block-in-c/

Also read answers of this question : http://stackoverflow.com/questions/3360860/catching-exceptions-thrown-in-the-constructor-of-the-target-object-of-a-using-blo/3360930#3360930

the first one is bettwer one

class Program
{
    static void Main(string[] args)
    {
        try
        {
            using (Foo f = new Foo())
            {
                //some commands that potentially produce exceptions.
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

because if you see the IL code of this try and catch block not wrap the inialization of the object.

Answer 2

Either is fine, depending on what you are going to do in the catch. If you need to use f in your catch then it needs to be within the using statement. However in your example there is no difference.

EDIT: As pointed out elsewhere it also depends on whether you are trying to catch just exceptions generated in the block following the using or including the object creation in the using statement. If it is in the block following the using then it is as I described. If you want to catch exceptions generated by Foo f = new Foo() then you need to use the first method.

Answer 3

I don't think it matters much, performance-wise. There is a slight difference though; in the second example, f is still available inside the exception handler, while in the first, it has gone out of scope. Conversely, in the first example, exceptions in the Foo constructor as well as its Dispose method will be caught, while in the second, they won't.

Either may or may not be what you want.

Answer 4

The first is better, because it will catch any exceptions thrown during the dispose process. Of course, you shouldn't throw any exceptions when disposing, but stuff happens.

Answer 5

Stackoverflow:- using-statement-with-try-catch-bloc

Answer 6

First one is the better one .if any exception comes it will catch.

 try
    {
        using (Foo f = new Foo())
        {
            //some commands that potentially produce exceptions.
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

The concept of using is it will dispose the object created in the using.i.e it automatically calls the IDispose method.Based on the requirement use the using.

Answer 7

Using is just

Foo f = null;
try
{
   f = new Foo();
}
finally
{
   if (f is IDisposable)
       f.Dispose();
}

Seeing that you can achive catching exceptions like this:

Foo f = null;
try
{
   f = new Foo();
}
catch (Exception ex)
{
    // handle exception
}
finally
{
   if (f is IDisposable)
       f.Dispose();
}

Answer 8

my answer is:

answer you find here

http://websitereckon.com

thanks