O que é o bloco C # Using e por que devo usá-lo?

Qual é o objective do bloco Using em C #? Como isso é diferente de uma variável local?

Se o tipo implementa IDisposable, ele automaticamente o descarta.

Dado:

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

Estes são equivalentes:

 SomeDisposableType t = new SomeDisposableType(); try { OperateOnType(t); } finally { t.Dispose(); } 

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

O segundo é mais fácil de ler e manter.

Using chamadas Dispose() após o using -block é deixado, mesmo se o código lança uma exceção.

Então você costuma usar para classs que exigem limpeza depois deles, como IO.

Então, esse bloco usando:

 using (MyClass mine = new MyClass()) { mine.Action(); } 

faria o mesmo que:

 MyClass mine = new MyClass(); try { mine.Action(); } finally { if (mine != null) mine.Dispose(); } 

Usar o using é muito mais curto e mais fácil de ler.

Do MSDN:

C #, através do Common Language Runtime (CLR) do .NET Framework, libera automaticamente a memory usada para armazenar objects que não são mais necessários. A liberação de memory é não-determinística; a memory é liberada sempre que o CLR decide executar a garbage collection. No entanto, geralmente é melhor liberar resources limitados, como identificadores de arquivos e conexões de rede, o mais rápido possível.

A instrução using permite que o programador especifique quando os objects que usam resources devem liberá-los. O object fornecido para a instrução using deve implementar a interface IDisposable. Essa interface fornece o método Dispose, que deve liberar os resources do object.

Em outras palavras, a instrução using diz ao .NET para liberar o object especificado no bloco using uma vez que ele não é mais necessário.

A instrução using é usada para trabalhar com um object em C # que implementa a interface IDisposable .

A interface IDisposable possui um método público chamado Dispose que é usado para descartar o object. Quando usamos a instrução using, não precisamos descartar explicitamente o object no código, a instrução using cuida disso.

 using (SqlConnection conn = new SqlConnection()) { } 

Quando usamos o bloco acima, internamente o código é gerado assim:

 SqlConnection conn = new SqlConnection() try { } finally { // calls the dispose method of the conn object } 

Para mais detalhes leia: Entendendo a instrução ‘using’ em C # .

Colocar código em um bloco de uso garante que os objects sejam descartados (embora não necessariamente coletados) assim que o controle deixar o bloco.

Além disso, observe que o object instanciado por meio de using é somente leitura dentro do bloco de uso. Consulte a referência oficial do C # aqui .

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

é equivalente a

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

Na verdade, é apenas um pouco de açúcar sintático que não exige que você chame explicitamente Dispose em membros que implementam IDisposable.

A instrução using obtém um ou mais resources, executa uma instrução e, em seguida, descarta o recurso.