4

I am working on application in which i need to access database. Use of using statement is good because "using" statement is to ensure that the object is always disposed correctly, and it doesn't require explicit code to ensure that this happens. So i am little bit confused where to use "using" and where to not.

public int route(Route r)
{
    try
    {
        using (SqlConnection con = new SqlConnection(connectionString))
        {
            using(SqlCommand com = new SqlCommand("",con))
            {
                using (SqlDataReader sdr = com.ExecuteReader())
                {
                }
            }
        }
    }
    catch (Exception e)
    {
    }
}
Sergey Litvinov
  • 7,408
  • 5
  • 46
  • 67
Hot Cool Stud
  • 1,145
  • 6
  • 25
  • 50

3 Answers3

15

Any time an object you create implements IDisposable, disposing of it (with or without the using syntactic sugar) is a good idea.

The benefit of the using block syntactic sugar (over manual .Dispose() calls) is that Dispose() will still be called even if there is an exception and flow leaves the using block.

Also, note that you can stack up the usings, without nested indentation:

using (SqlConnection con = new SqlConnection(connectionString))
using (SqlCommand com = new SqlCommand("",con))
using (SqlDataReader sdr = com.ExecuteReader()) // Still need to open connection ...
{
   ...

As an aside, a further benefit of using is that if the IDisposable variable is declared within the using, it that the variable is readonly and cannot be reassigned within the block, e.g.:

using (SqlDataReader sdr = com.ExecuteReader())
{
   sdr = new SqlDataReader() // Error
Click Ok
  • 8,700
  • 18
  • 70
  • 106
StuartLC
  • 104,537
  • 17
  • 209
  • 285
  • If i am not using nested indentation then how will i ensure that the object disposed correctly because object is disposed at the end of block. – Hot Cool Stud Mar 11 '14 at 12:18
  • 2
    @HotCoolStud don't worry.Compiler will take care of that.It is smart enough to understand that you want nested statements and that's why it's a valid syntax. – Selman Genç Mar 11 '14 at 12:19
  • I had no idea one could do that! :D But I sure hope you are right that the compiler will dispose of objects in a LIFO-kind of order because this could be a problem otherwise. – Crono Mar 11 '14 at 12:21
4

You can simplify it like this:

using (SqlConnection con = new SqlConnection(connectionString))
using(SqlCommand com = new SqlCommand("",con))
using (SqlDataReader sdr = com.ExecuteReader())
{
     ...
}

Using statements are translated to try/finally blocks.Therefore your object will be Disposed even if there is an exception thrown.So if you have a Disposable object and you want to ensure that it will be Disposed after it's used, you can use using statements.Remember it's kind a syntactic sugar for this:

SqlCommand cmd;
try
{
    cmd = new SqlCommand();
    ...
}
finally
{
   ((IDisposable)cmd).Dispose();
}
Selman Genç
  • 100,147
  • 13
  • 119
  • 184
3

This looks okay as far as using blocks are concerned.

However, you should NOT use a try/catch block here, unless you intend on actually doing something with the exception. Otherwise you are just hiding possible errors away, which is dead wrong.

Crono
  • 10,211
  • 6
  • 43
  • 75