Understanding the 'using' statement in C#

Understanding the 'using' statement in C#
By TiNgZ aBrAhAm

Understanding the 'using' statement in C# 

Introduction

This article is an introduction to the

using

statement in c# and also provides some insight into the actual implementation of the statement.

The Code

When you are using an object that encapsulates any resource, you have to make sure that when you are done with the object, the object's

Dispose

method is called. This can be done more easily using the

using

statement in C#. The

using

statement simplifies the code that you have to write to create and then finally clean up the object. The using statement obtains the resource specified, executes the statements and finally calls the

Dispose

method of the object to clean up the object. The following piece of code illustrates its use.

using (TextWriter w = File.CreateText("log.txt"))
{
w.WriteLine("This is line one");
}

Now that's cool. But before we can start using this code, let us try to understand what happens behind the screen. Lets have a look at the IL code for the above code section.

.locals init ([0] class [mscorlib]System.IO.TextWriter w)
IL_0000:  ldstr      "log.txt"
IL_0005:  call       class [mscorlib]System.IO.StreamWriter
[mscorlib]System.IO.File::CreateText(string)
IL_000a:  stloc.0

.try
{
IL_000b:  ldloc.0
IL_000c:  ldstr      "This is line one"
IL_0011:  callvirt   instance void [mscorlib]
System.IO.TextWriter::WriteLine(string)
IL_0016:  leave.s    IL_0022
}  // end .try
finally
{
IL_0018:  ldloc.0
IL_0019:  brfalse.s  IL_0021
IL_001b:  ldloc.0
IL_001c:  callvirt   instance void [mscorlib]
System.IDisposable::Dispose()
IL_0021:  endfinally
}  // end handler

Hmmmm.... Well doesn't look like this is my code. That's because I see a

try

and a

finally

in the IL code (something that I haven't implemented). Wait a minute. IT IS MY CODE....

Waaaaaah... Somebody changed my code...

Well the truth is, somebody did change your code. The CLR. The CLR converts your code into MSIL. And the

using

statement gets translated into a

try

and

finally

block. This is how the

using

statement is represented in IL. A

using

statement is translated into three parts: acquisition, usage, and disposal. The resource is first acquired, then the usage is enclosed in a

try

statement with a

finally

clause. The object then gets disposed in the

finally

clause. For example the following lines of code using the

using

statement,

 

using (MyResource myRes = new MyResource())
{
myRes.DoSomething();

}

gets translated to,

MyResource myRes= new MyResource();
try
{
myRes.DoSomething();
}
finally
{
// Check for a null resource.
if (myRes!= null)
// Call the object's Dispose method.
((IDisposable)myRes).Dispose();
}

Hmmm... That explains it.

The above code that uses the

using

statement corresponds to one of the two possible expansions. When

MyResource

is a value type, the expansion in the

finally

block will be

finally

{

((IDisposable)myRes).Dispose();

}

If

MyResource

is of reference type, the expansion becomes

finally{if(myRes != null)
((IDisposable)myRes).Dispose();}

This way, if a

null

resource is acquired, then no call will be made to

Dispose

, thus avoiding any exception that occurs.
Well, that explains everything.

Using '

using

'

A typical scenario where we could use the

using

statement is :

string connString = "Data Source=localhost;Integrated " +
"Security=SSPI;Initial Catalog=Northwind;";

using (SqlConnection conn = new SqlConnection(connString))
{SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "SELECT ID, Name FROM Customers";

conn.Open();

using (SqlDataReader dr = cmd.ExecuteReader())
{while (dr.Read())
Console.WriteLine("{0}/t{1}", dr.GetString(0), dr.GetString(1));
}}

Note

The

using

statement is only useful for objects with a lifetime that does not extend beyond the method in which the objects are constructed. Remember that the objects you instantiate must implement the

System.IDisposable

interface.

There is no equivalent for the

using

statement in vb.net. You have to use the

try finally

block.

Details at http://www.codeproject.com/csharp/TinguUsingStatement.asp