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.