What is the C# Using block and why should I use it?

Question

What is the purpose of the Using block in C#? How is it different from a local variable?

Answer 1

Using calls Dispose() after the using-block is left, even if the code throws an exception.

So you usually use using for classes that require cleaning up after them, like IO.

So, this using block:

using (MyClass mine = new MyClass())
{
  mine.Action();
}

would do the same as:

MyClass mine = new MyClass();
try
{
  mine.Action();
}
finally
{
  if (mine != null)
    mine.Dispose();
}

Using using is way shorter and easier to read.

Answer 2

Placing code in a using block ensures that the objects are disposed (though not necessarily collected) as soon as control leaves the block.

Answer 3

If the type implements IDisposable, it automatically disposes it.

Given:

public class SomeDisposableType : IDisposable
{
   ...implmentation details...
}

These are equivalent:

SomeDisposableType t = new SomeDisposableType();
try {
    OperateOnType(t);
}
finally {
   t.Dispose();
}

using (SomeDisposableType u = new SomeDisposableType()) {
    OperateOnType(u);
}

The second is easier to read and maintain.

Answer 4

From MSDN:

C#, through the .NET Framework common language runtime (CLR), automatically releases the memory used to store objects that are no longer required. The release of memory is non-deterministic; memory is released whenever the CLR decides to perform garbage collection. However, it is usually best to release limited resources such as file handles and network connections as quickly as possible.

The using statement allows the programmer to specify when objects that use resources should release them. The object provided to the using statement must implement the IDisposable interface. This interface provides the Dispose method, which should release the object's resources.

In other words, the using statement tells .NET to release the object specified in the using block once it is no longer needed.

Answer 5

It is really just some syntatic sugar that does not require you to explicity call Dispose on members that implement IDisposable.

Answer 6

using (B a = B())
{
   DoSomethingWith(a);
}

is equivalent to

B a = new A();
try
{
  DoSomethingWith(a);
}
finally
{
   ((IDisposable)a).Dispose();
}

Answer 7

The using statement obtains one or more resources, executes a statement, and then disposes of the resource.