Understanding the 'using' statement in C#

转载 2006年05月25日 11:53:00

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

Understanding Python's "with" statement

http://effbot.org/zone/python-with-statement.htm Understanding Python's "with" statement Fre...

Understanding and Implementing Observer Pattern in C++

Introduction This article presents the basics of Observer Pattern, when to use it and how to implem...

Understanding CS Fallback in LTE

Understanding CS Fallback in LTE LTE technology supports packet based services only, howeve...

understanding hard links and symbolic links in Linux.

Hard Links Hard links are the original Unix way of creating links, compared to symbolic links, whic...

Understanding mappedBy annotation in Hibernate

I am trying to understand the mappedBy attribute of @OneToMany annotation in JPA. I created below ex...

Understanding “extern” keyword in C

http://www.geeksforgeeks.org/archives/840 July 19, 2009 I’m sure that this post will be ...

Understanding Garbage Collection in the .NET Framework.

In this article we will explore the Garbage Collection feature in the .Net framework and the activit...

Note of big data dummies:Understanding the role of relational databases in big data

PostgresSQL (www.postgressql.org), a technology we talk about in Chapter 7, is the most widely used...

An understanding of two important built-in functions(__str__ And __repr__)

两个重要内置函数的理解(str和repr) 内建函数str()和repr()(representation,表达,表示)或反引号操作符(‘’)可以方便地以字符串的方式获取对象的内容、类型、数值属性...

Understanding Bidirectional (BIDI) Text in Unicode

http://www.iamcal.com/understanding-bidirectional-text/ By Cal Henderson, March 1st 2009. The Ba...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Understanding the 'using' statement in C#
举报原因:
原因补充:

(最多只允许输入30个字)