Difference between 'using' and 'normal' DB Connection

Question

I wonder that what is the difference between ;

using (var con = new OracleConnection(oradb))
            {
                con.Open();
                // Do sth.
                con.Dispose();
                con.Close();
            }

from this;

oradb = ConString;
OracleConnection con = new OracleConnection(oradb))
con.Open();
// Do Sth.
con.Dispose();
con.Close();

Both of them works for me, However didn't understand the basic behind of this.

Which one should i use ?

The using ensures that the connection gets disposed even in case of error. You need a `try...catch...finally` to achieve the same. So it's a less verbose version. The `con.Close` and `con.Dispose` are redundant because that is what the using statement does for you(`Dispose` will close the connection). — Tim Schmelter, Nov 27 '17 at 14:05
`Close` will call `Dispose`. So in your first example with `using` you´re effectivly calling `Dispose` disposing three times, once directly, once by `Close` and last time when leaving the `using`-block. See also https://stackoverflow.com/questions/61092/close-and-dispose-which-to-call — MakePeaceGreatAgain, Nov 27 '17 at 14:13

score 1 · Answer 1 · edited Nov 27 '17 at 16:47

using with dispose your connection object automatically. you dont have to do it manually.

using(var con = new OracleConnection(oradb))
{
  con.Open();
}

is equal to (some what similar , you can use ILDSAM on your code and check)

OracleConnectioncon = null;
try
{
  con = new OracleConnection(oradb);
  con.Open();
}
finally
{
  con.Disponse();
}

you can clear you concept by reading : Dispose Pattern

score 1 · Answer 2 · answered Nov 27 '17 at 14:06

1

Using ensures that the connection is always disposed. If you dispose it manually it can happen that part of the code is never executed at all.

answered Nov 27 '17 at 14:06

Ivan Ičin

9,672
5
36
57

Pac0 · Answer 3 · 2017-11-27T14:13:10.317

1

With using, disposing of connection is handled automaticaly :

using (var con = new OracleConnection(oradb))
        {
            con.Open();
            // Do sth.
            con.Close();
        } // ok

edited Nov 27 '17 at 14:13

answered Nov 27 '17 at 14:06

Pac0

21,465
8
65
74

The `Close()` is no handled, should be called explicitly. – Cleptus Nov 27 '17 at 14:09
@bradbury9 thanks, edited. – Pac0 Nov 27 '17 at 14:13

score 1 · Accepted Answer · answered Nov 27 '17 at 14:07

If we look at the decompiled code:

using System;
public class C {
    public void M() {
        using(var conn = new Connection()){
        }
    }
}

is turned into:

public class C
{
    public void M()
    {
        Connection connection = new Connection();
        try
        {
        }
        finally
        {
            if (connection != null)
            {
                ((IDisposable)connection).Dispose();
            }
        }
    }
}

Unlike the code without a using block, the connection will be disposed even if the exception is thrown.

A bit more reading about the using could be found here (C# Reference doc)

The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object. You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; in fact, this is how the using statement is translated by the compiler.

Difference between 'using' and 'normal' DB Connection

4 Answers4