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

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

If the type implements IDisposable, it automatically disposes that type.

Given:

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

These are equivalent:

SomeDisposableType t = new SomeDisposableType();
try {
    OperateOnType(t);
}
finally {
    if (t != null) {
        ((IDisposable)t).Dispose();
    }
}

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

The second is easier to read and maintain.

---

Since C# 8 there is a new syntax for using that may make for more readable code:

using var x = new SomeDisposableType();

It doesn't have a { } block of its own and the scope of the using is from the point of declaration to the end of the block it is declared in. It means you can avoid stuff like:

string x = null;
using(var someReader = ...)
{
  x = someReader.Read();
}

And have this:

using var someReader = ...;
string x = someReader.Read();

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.

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.

The using statement is used to work with an object in C# that implements the IDisposable interface.

The IDisposable interface has one public method called Dispose that is used to dispose of the object. When we use the using statement, we don't need to explicitly dispose of the object in the code, the using statement takes care of it.

using (SqlConnection conn = new SqlConnection())
{

}

When we use the above block, internally the code is generated like this:

SqlConnection conn = new SqlConnection() 
try
{

}
finally
{
    // calls the dispose method of the conn object
}

For more details read: Understanding the 'using' statement in C#.

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

is equivalent to

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

Also take note that the object instantiated via using is read-only within the using block. Refer to the official C# reference here.

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

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

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