what's the point of the 'using' construct?

[Mike P]

I have only ever seen this used like this :

try
{
using (SqlConnection conn = new SqlConnection())
{
//db stuff
}
catch
{
}

What advantage do you get from using this? And are there any other uses
for this?

*** Sent via Developersdex http://www.developersdex.com ***

[Mel]

Using closes the connection and frees the resource.
"Mike P" <mi*******@gmail.comwrote in message
news:e9**************@TK2MSFTNGP03.phx.gbl...

>I have only ever seen this used like this :

try
{
using (SqlConnection conn = new SqlConnection())
{
//db stuff
}
catch
{
}

What advantage do you get from using this? And are there any other uses
for this?

*** Sent via Developersdex http://www.developersdex.com ***

[Nicholas Paldino [.NET/C# MVP]]

Mike,

Well, "using" in general is used to make sure that instances that
implement IDisposable are always called when the code block is exited.

The reason people wrap try/catch blocks around the using statement is to
catch an exception if the block is exited as the result of an exception
being thrown.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard.caspershouse.com

"Mike P" <mi*******@gmail.comwrote in message
news:e9**************@TK2MSFTNGP03.phx.gbl...

>I have only ever seen this used like this :

try
{
using (SqlConnection conn = new SqlConnection())
{
//db stuff
}
catch
{
}

What advantage do you get from using this? And are there any other uses
for this?

*** Sent via Developersdex http://www.developersdex.com ***

[Michael Nemtsev]

Hello Mike,

Read this http://msdn2.microsoft.com/en-us/library/yh598w02.aspx

MPI have only ever seen this used like this :
MP>
MPtry
MP{
MPusing (SqlConnection conn = new SqlConnection())
MP{
MP//db stuff
MP}
MPcatch
MP{
MP}
MPWhat advantage do you get from using this? And are there any other
MPuses for this?

---
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche

[Peter Bromberg [C# MVP]]

The main advantage is that Dispose is called on the target as soon as the
closing brace is reached. That in itself is a good thing.
Peter

--
Co-founder, Eggheadcafe.com developer portal:
http://www.eggheadcafe.com
UnBlog:
http://petesbloggerama.blogspot.com


"Mike P" wrote:

I have only ever seen this used like this :

try
{
using (SqlConnection conn = new SqlConnection())
{
//db stuff
}
catch
{
}

What advantage do you get from using this? And are there any other uses
for this?

*** Sent via Developersdex http://www.developersdex.com ***

[WhiteWizard]

Mike,

The "using" statement has two benefits; makes your code simpler, and more
efficient.

When you use the "using" statement, the compiler puts any code inside the
brackets inside a TRY/FINALLY block, and inside the FINALLY block it calls
the DISPOSE method (which means you can only use it with classes that
implement IDisposable).

This has the advantage of you not having to code calls to the Close or
Dispose method, which if you get it wrong could cause an
ObjectDisposedException to be thrown, AND it allows the CLR/Garbage Collector
to collect it sooner in most cases.

HTH

Gandalf
MCSD.NET, MCAD, MCT
"Mike P" wrote:

I have only ever seen this used like this :

try
{
using (SqlConnection conn = new SqlConnection())
{
//db stuff
}
catch
{
}

What advantage do you get from using this? And are there any other uses
for this?

*** Sent via Developersdex http://www.developersdex.com ***

[Tom Porterfield]

Mel wrote:

Using closes the connection and frees the resource.

No, using guarantees that Dispose is called once the using block is exited.
In the case of an SqlConnection, its dispose also closes the connection if
it is open, but "using" does not do that. The GC will free the resource at
some later time.
--
Tom Porterfield

[Mike P]

Many thanks for the explanations guys!

Cheers,

Mike
*** Sent via Developersdex http://www.developersdex.com ***

[Mike P]

So in my Data Access layer I am now using the using contruct like this
below. Is it correct to put my try catch block, and my return statement
inside the using block or should they be outside it?

public DBResult AddCompetitorMachine(int intCompetitor, string
strMachine)
{
using (SqlConnection objConnection = new
SqlConnection(ConfigurationManager.ConnectionStrin gs["ConnectionString"]
..ConnectionString))
{
DBResult dbrAddMachine;

SqlCommand objCommand = new
SqlCommand("AddCompetitorMachine", objConnection);
objCommand.CommandType = CommandType.StoredProcedure;

SqlParameter prmCompetitor = new SqlParameter("@Competitor",
SqlDbType.Int, 4);
prmCompetitor.Value = intCompetitor;
objCommand.Parameters.Add(prmCompetitor);

SqlParameter prmMachine = new SqlParameter("@Machine",
SqlDbType.VarChar, 50);
prmMachine.Value = strMachine;
objCommand.Parameters.Add(prmMachine);

SqlParameter prmCompetitorMachineID = new
SqlParameter("@CompetitorMachineID", SqlDbType.Int, 4);
prmCompetitorMachineID.Direction =
ParameterDirection.Output;
objCommand.Parameters.Add(prmCompetitorMachineID);

try
{
objConnection.Open();
objCommand.ExecuteNonQuery();

if (prmCompetitorMachineID.Value != System.DBNull.Value)
{
dbrAddMachine = DBResult.OK;
}
else
{
dbrAddMachine = DBResult.Error;
}
}
catch
{
dbrAddMachine = DBResult.Error;
}

return dbrAddMachine;
}
}
*** Sent via Developersdex http://www.developersdex.com ***

[Tom Porterfield]

Mike P wrote:

So in my Data Access layer I am now using the using contruct like this
below. Is it correct to put my try catch block, and my return statement
inside the using block or should they be outside it?

It is fine to put those inside the using block.
--
Tom Porterfield