What is the point of having using blocks in C# code?

Question

I see loads of code snippets with the following Syntax

using (RandomType variable = new RandomType(1,2,3))
{
   // A bunch of code here.

}

why not just declare the variable and use it?

This Using syntax seems to just clutter the code and make it less readable. And if it's so important that that varible is only available in that scope why not just put that block in a function?

Answer 1

using (RandomType variable = new RandomType(1,2,3))
{
   // A bunch of code here.
}

is pretty much the same (with a few subtle differences) as:

RandomType variable = new RandomType(1,2,3);

try
{
    // A bunch of code
}
finally
{
    if(variable != null)
        variable.Dispose()
}

Note that when calling "Using", you can cast anything as IDisposable:

using(RandomType as IDisposable)

The null check in the finally will catch anything that doesn't actually implement IDisposable.

Answer 2

Using has a very distinct purpose.

It is designed for use with types that implement IDisposable.

In your case, if RandomType implements IDisposable, it will get .Dispose()'d at the end of the block.

Answer 3

An object being used in a using statement must implement IDisposable, so at the end of the scope, you're guaranteed that Dispose() will be called, so theoretically, your object should be released at that point. In some cases, I've found it makes my code clearer.

Answer 4

No, it does not clutter your code , or make it less readable.

A using statement can only be used on IDisposable types (that is, types that implement IDisposable).

By using that type in a using - block, the Dispose method of that type will be used when the scope of the using-block ends.

So, tell me which code is less readable for you:

using( SomeType t = new SomeType() )
{
   // do some stuff
}

or

SomeType t = new SomeType();

try
{
   // do some stuff
}
finally
{
   if( t != null ) 
   {
      t.Dispose();
   }
}

Answer 5

The using keyword provides a deterministic way to clean up the managed or unmanaged resources that an object allocates. If you don't use the using keyword, you are responsible to call Dispose() (or in some cases, Close()) when finished with that object. Otherwise, the resources may not be cleaned up until the next garbage collection, or even not at all.

Answer 6

According to MSDN, the following using code:

using (Font font1 = new Font("Arial", 10.0f)) 
{
    byte charset = font1.GdiCharSet;
}

expands to this:

{
  Font font1 = new Font("Arial", 10.0f);
  try
  {
    byte charset = font1.GdiCharSet;
  }
  finally
  {
    if (font1 != null)
      ((IDisposable)font1).Dispose();
  }
}

And it does really not clutter your code. Quite the opposite actually!