Usage of a using statement

Answer 1

The using statement is for any object which implements IDisposable.

using (var my_object = new IDisposableObject ())
{

    //do my_object code here.


} //once the program reaches here, it calls my_object.Dispose();

Generally, this is used for objects with connections that manually need to be handled (closed) when the program is finished with them. For example, open connections to files and to the database.

The using statement will call Dispose even if there is an error in the code so it is akin to calling the Dispose method in a finally block of the try catch statement.

Example/Tutorial

Answer 2

There are 2 fundamental ways you can use the using statement. As extracted from using Directive (C#) from MSDN.

• Create an alias for a namespace (a using alias).
• Permit the use of types in a namespace, such that, you do not have to qualify the use of a type in that namespace (a using directive).

Answer 3

It's a shorter syntax to make sure that dispose is called:

using (File f = File.Open("..."))
{

}

is the same as

File f;
try
{
  f = File.Open("...");
}
finally
{
  f.Dispose();
}

Answer 4

Just to expand on Kevin's answer, a using statement effectively wraps your object instantiation in a try/finally block calling the object Dispose() method in the finally section i.e.

using(myObject m = new myObjecyt())
{
   // Code here
}

is the same as

myObject m = new myObjecyt()
try
{
   // Code here
}
finally
{
   m.Dispose();
}

this can be verified by checking the MSIL.

Answer 5

The "Using" keyword helps do a certain thing to be done safely and clearly in .net. This is propertly disposing of certain objects. You may have learned how in .Net we have garbage collection, which means for many object we don't have to care about them when we are done using them. Other object however need to have a method called on them called Dispose. The best practice is that whenever an object has a Dispose method, then we should call that method when we're done with that object.

(They typically handle unmanaged resources. This means that it's using memory or other computer parts that are outside the control of the .NET runtime. So, when garbage collection reaches the discarded .Net object, it is unable to propertly let go of these resources. This can cause memory leaks and all kinds of other problems. A good example is an ADO.NET Connection object. Repeatedly not Disposing of your connection objects can cause DB problems.)

The Using keyword is also tied to this "Dispose" method. It's more accurate to say that when an object has a Dispose method, we either (A.) call .Dispose when we're done with it, or (B.) put our code that uses that object within a Using block. The Using block does several things for you:

• When the code moves out of the block, the important Dispose method is automatically called for you.
• More importantly, if there is an error in the code block, the Dispose method will still be called. This is why the using block is really helpful. Otherwise you have to put in a lot of error handling code.

The key is that for many of these object that have a Dispose method, error handling is particularly imortant. For a lot our code we don't need error handling; the consequences of an error happening are not really a problem. But for these IDisposable objects errors are often a problem, maybe a big problem. So, .Net provides a syntax for busy developers to add the most basic error handling and move on. Always start off with a Using block at least; maybe later you'll move to fancier error handling, but at least you've got this basic safety.

Here's a good explanation of the Using keyword.