What about the using construct in c#

Question

I see this:

using (StreamWriter sw = new StreamWriter("file.txt"))
{
     // d0 w0rk s0n
}

Everything I try to find info on is does not explain what this doing, and instead gives me stuff about namespaces.

Answer 1

You want to check out documentation for the using statement (instead of the using directive which is about namespaces).

Basically it means that the block is transformed into a try/finally block, and sw.Dispose() gets called in the finally block (with a suitable nullity check).

You can use a using statement wherever you deal with a type implementing IDisposable - and usually you should use it for any disposable object you take responsibility for.

A few interesting bits about the syntax:

• You can acquire multiple resources in one statement:

  using (Stream input = File.OpenRead("input.txt"),
         output = File.OpenWrite("output.txt"))
  {
      // Stuff
  }
  

• You don't have to assign to a variable:

  // For some suitable type returning a lock token etc
  using (padlock.Acquire())
  {
      // Stuff
  }
  

• You can nest them without braces; handy for avoiding indentation

  using (TextReader reader = File.OpenText("input.txt"))
  using (TextWriter writer = File.CreateText("output.txt"))
  {
      // Stuff
  }
  

Answer 2

The using construct is essentially a syntactic wrapper around automatically calling dispose on the object within the using. For example your above code roughly translates into the following

StreamWriter sw = new StreamWriter("file.text");
try {
  // do work 
} finally {
  if ( sw != null ) {
    sw.Dispose();
  }
}

Answer 3

Here you go: http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Basically, it automatically calls the Dispose member of an IDisposable interface at the end of the using scope.

Answer 4

Your question is answered by section 8.13 of the specification.

Answer 5

check this Using statement

Answer 6

It scopes the object(s) created at the beginning of the 'using' statement - Dispose() is automatically called when the block terminates. The object(s) must be convertible to IDisposable.