Functional Equivalence?

[Dinsdale]

I wanted to know if the using statement is functionally the same as
try{}finally{} when applied to ADO.Net. So, are these two following
code samples functionally equivalent?

public void SaveMessageData(string strTransaction)
{
SqlCommand comCommand = new SqlCommand(strTransaction,
new SqlConnection(ConnectionString));

try
{
comCommand.Connection.Open();
comCommand.ExecuteNonQuery();
}
finally
{
if(comCommand.Connection.State != ConnectionState.Closed)
{
comCommand.Connection.Close();
}
}

}

AND...

public void SaveMessageData(string strTransaction)
{
SqlCommand comCommand = new SqlCommand(strTransaction,
new SqlConnection(ConnectionString));

using(comCommand)
{
comCommand.Connection.Open();
comCommand.ExecuteNonQuery();
}
}

I ask this because I saw some example code from Microsoft that uses the
'using' statement in a file access scenario. The author does not
explicitly close the file after writing to it but the code works fine.

Note that I do not use the catch() portion of the TryCatchFinally
because I want all exceptions from my DAL to bubble up.
Cheers!
Russ

[Mehdi]

On 30 May 2006 15:07:19 -0700, Dinsdale wrote:

I wanted to know if the using statement is functionally the same as
try{}finally{} when applied to ADO.Net. So, are these two following
code samples functionally equivalent?

When you are using the using statement, the compiler transforms it into a
try/finally statement and calls Dispose() in the finally block. So you 2
code sample are not exactly equivalent. I'm not sure if the SqlCommand's
Dispose() method closes its connection. A better way to write it would be:

public void SaveMessageData(string strTransaction)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlCommand comCommand = new SqlCommand(strTransaction,
conn);
comCommand.Connection.Open();
comCommand.ExecuteNonQuery();
}
}

With the above code, the using statement ensures that the connection will
be closed no matter what.

[sdbillsfan]

When you have questions like this you should take a look "under the
hood" using the ildasm tool.
http://msdn2.microsoft.com/en-us/library/f7dy01k1.aspx

Here's the IL from your function with the "using" statement, see it
translates to a try/finally format and calls IDisposable.Dispose() as
the other poster indicated.

.maxstack 3
.locals init ([0] class [System.Data]System.Data.SqlClient.SqlCommand
comCommand,
[1] class [System.Data]System.Data.SqlClient.SqlCommand
CS$00000005$00000000)
IL_0000: ldarg.1
IL_0001: ldarg.0
IL_0002: ldfld string test::ConnectionString
IL_0007: newobj instance void
[System.Data]System.Data.SqlClient.SqlConnection::.ctor(string)
IL_000c: newobj instance void
[System.Data]System.Data.SqlClient.SqlCommand::.ctor(string,

class
[System.Data]System.Data.SqlClient.SqlConnection)
IL_0011: stloc.0
IL_0012: ldloc.0
IL_0013: stloc.1
.try
{
IL_0014: ldloc.0
IL_0015: callvirt instance class
[System.Data]System.Data.SqlClient.SqlConnection
[System.Data]System.Data.SqlClient.SqlCommand::get_Connection()
IL_001a: callvirt instance void
[System.Data]System.Data.SqlClient.SqlConnection::Open()
IL_001f: ldloc.0
IL_0020: callvirt instance int32
[System.Data]System.Data.SqlClient.SqlCommand::ExecuteNonQuery( )
IL_0025: pop
IL_0026: leave.s IL_0032
} // end .try
finally
{
IL_0028: ldloc.1
IL_0029: brfalse.s IL_0031
IL_002b: ldloc.1
IL_002c: callvirt instance void
[mscorlib]System.IDisposable::Dispose()
IL_0031: endfinally
} // end handler
IL_0032: ret

[Dinsdale]

Thanks for the quick response guys.

I wish you hadn't shown me that tool, I'm not going to get any work
done now... ;)

Russ

[John B]

Dinsdale wrote:

I wanted to know if the using statement is functionally the same as
try{}finally{} when applied to ADO.Net. So, are these two following
code samples functionally equivalent?

I think equivalent would be:

....
try
{
...
}
finally
{
comCommand.Dispose();
}

JB
public void SaveMessageData(string strTransaction)
{
SqlCommand comCommand = new SqlCommand(strTransaction,
new SqlConnection(ConnectionString));

try
{
comCommand.Connection.Open();
comCommand.ExecuteNonQuery();
}
finally
{
if(comCommand.Connection.State != ConnectionState.Closed)
{
comCommand.Connection.Close();
}
}

}

AND...

public void SaveMessageData(string strTransaction)
{
SqlCommand comCommand = new SqlCommand(strTransaction,
new SqlConnection(ConnectionString));

using(comCommand)
{
comCommand.Connection.Open();
comCommand.ExecuteNonQuery();
}
}

I ask this because I saw some example code from Microsoft that uses the
'using' statement in a file access scenario. The author does not
explicitly close the file after writing to it but the code works fine.

Note that I do not use the catch() portion of the TryCatchFinally
because I want all exceptions from my DAL to bubble up.
Cheers!
Russ

[Marc Gravell]

I won't mention Reflector, then ;-p
Quite simply invaluable for disecting (non-obfuscated) .Net code... and it's
friendlier that ILDASM (e.g. pick an assembly, then a class, then member,
then disassemble into any of IL, C#, VB, Delphi, MC++ or Chrome, or leap
directly into the MSDN, or the online help, or see what uses it, etc.
Invaluable.

http://www.aisto.com/roeder/dotnet/