What is the purpose of the Using
block in C#? How is it different from a local variable?
This question is related to
c#
.net
syntax
using
using-statement
using (B a = new B())
{
DoSomethingWith(a);
}
is equivalent to
B a = new B();
try
{
DoSomethingWith(a);
}
finally
{
((IDisposable)a).Dispose();
}
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.
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 obtains one or more resources, executes a statement, and then disposes of the resource.
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.
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.
Placing code in a using block ensures that the objects are disposed (though not necessarily collected) as soon as control leaves the block.
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#.
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.
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.
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#.
Also take note that the object instantiated via using
is read-only within the using block. Refer to the official C# reference here.
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.
It is really just some syntatic sugar that does not require you to explicity call Dispose on members that implement IDisposable.
using (B a = new B())
{
DoSomethingWith(a);
}
is equivalent to
B a = new B();
try
{
DoSomethingWith(a);
}
finally
{
((IDisposable)a).Dispose();
}
It is really just some syntatic sugar that does not require you to explicity call Dispose on members that implement IDisposable.
Placing code in a using block ensures that the objects are disposed (though not necessarily collected) as soon as control leaves the block.
using (B a = new B())
{
DoSomethingWith(a);
}
is equivalent to
B a = new B();
try
{
DoSomethingWith(a);
}
finally
{
((IDisposable)a).Dispose();
}
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.
Source: Stackoverflow.com