use of “using” keyword in c# [duplicate]

Answer 1

using can be used to:

• "import" namespaces, i.e. use them
• create an alias for a type (like typedef back in the c++ days)
• dispose an object immediatly after it's usage

Answer 2

There are two uses of the keyword.

One is when you are too lazy to type System.Web.UI.WebControls.TextBox you add using System.Web.UI.WebControls at the top of your code file and henceforth just write TextBox. That's all it does - shortens the code you have to write (and makes it easier to read).

The other one has to do with the IDisposable interface. This interface is for objects that need to be cleaned up after you are done using them. Like files, that need to be closed, or DB connections, or that kind of stuff. You could just simply place a call to the Dispose() method yourself wherever needed, but this makes it easier. In short, this:

using (var X = new MyObject())
{
    // Code goes here
}

is equivalent to this:

var X = new MyObject();
try
{
    // Code goes here   
}
finally
{
    if ( X != null )
        X.Dispose();
}

Again - it's a shorthand for a piece of code that ensures, that no matter what happens, the Dispose() method will get called. Even when your code throws an exception, or you return out of the method, the Dispose() method will get called. This ensures that you don't accidentally leave files open or something.

In general, if you ever use an object that implements the IDisposable interface, place it in a using block.

Answer 3

using has two meanings in C#:

• using for IDisposable means that when the block of using ends Dispose method will be called.
• using for namespace means that the types from the imported namespace will be referenced in code.

Basic example of how using block works:

A "dummy" disposable class:

public class DisposableClass : IDisposable
{
    public static bool WasDisposed { get; private set;}

    public void Dispose()
    {
        WasDisposed = true;
    }
}

Some very simple code that demonstrates when Dispose is called:

[Test]
public void DisposeSample()
{
    using (var disposableClass = new DisposableClass())
    {
        Assert.IsFalse(DisposableClass.WasDisposed);
    }

    Assert.IsTrue(DisposableClass.WasDisposed);
}

Answer 4

There are two uses of the 'using' keyword:

• as a using directive, which permits the use of types in a namespace. For example: using System.Web

• as a using statement, which is only possible for types that inherit from IDisposable. This automatically calls the Dispose() method on the object after the using statement goes out of scope, so you don't have to worry about automatically calling this method yourself, or calling Close() on database connections, for example:

  using(MySqlConnection connection = new MySqlConnection()) { //.. }

Answer 5

using keyword can be used to import(Associate) a namspace or library with our program.so that we can use function available in that libraries in our program. Its some thing like a reference

Ex : using System.IO

This means We are going to use some functions present in that library

You can write your own library and import it using the using statement. Ex :

namespace MyProject.MyNamspace
{
 public class MyCustomClass
 {
  public static string MyFunctionToSmile()
  {
   return "He he he heeee";
  }   
}

}

and in ur c# page, use this

using MyProject.MyNamspace

public class MyClass
{
 protected void Page_Load(object sender, EventArgs e)
 {
  Response.Write(MyCustomClass.MyFunctionToSmile());
 } 
}

Cool...!

Answer 6

There are three uses:

• As a directive (two uses) to import namespaces and alias types
• As a statement to dispose of IDisposable objects at the end of the scope

I don't believe I can explain more clearly than the MSDN articles in general terms. If you have trouble understanding them, you might be better to post a more specific question regarding the details you don't understand.