Muito tem de fomentado sobre o uso do (using) e a maioria dos profissionais que conheço não tem a menor ideia de onde e/ou como usar.

Para simplificar, o (using) dispara a interface System.IDisposable de uma classe (se essa a implementar).

Usualmente as classes que implementam essa interface fazem uso de recursos não gerenciados no .net. Como exemplo, temos as classes de desenho (Bitmap e Graphics) e as classes de acesso à arquivo (StreamReader, StreamWriter, FileStream).

O correto uso dessa interface evita muitos problemas, pois, o que está em uso no (using) SEMPRE terá seu método Dispose() executado, mesmo em caso de erros.

Em situações críticas como abertura/fechamento de arquivos, o uso da interface IDisposable garante que os recursos não gerenciados serão finalizados e o mais importante, que o arquivo será fechado. Isso mesmo, o arquivo será fechado.

Adicionamente ao uso desse recurso, a não finalização de recursos não gerenciados faz com que (enquando a aplicação estiver rodando) todas as informações em memória utilizadas de forma não gerenciada sejam de forma permanente armazenadas. Isso na prática significa que se você estiver abrindo um arquivo e não executar o Dispose(), mesmo que o método termine, o Garbagge Collector NUNCA, isso mesmo, NUNCA irá remover esses recursos. Pessoalmente já ví uma dezena de aplicações Web e Windows que consomem rios de memória e os programadores nunca souberam o porque :(

Em fim, vamos a um exemplo que neste post foi gerado por uma Console Application.

namespace ConsoleApplicationDemonstracaoDisposable
{
   class Program
   {
      static void Main(string[] args)
      {
         DisposeDemo demoI = new DisposeDemo();
         DisposeDemo demoII = new DisposeDemo();
         // Exemplo de Utilização I - using()
         using (demoI)
         {
            // Esse é o melhor cenário, se ocorrer um erro de processamento dentro de um block (using), a interface IDisposable da classe especificada será executada de forma arbitrária.
         }
         // Exemplo de Utilização II - Dispose();
         demoII.Dispose();
      }
   }
   public class DisposeDemo : System.IDisposable
   {
      /// <summary>
      /// Método Implementado pela Interface System.IDisposable
      /// </summary>
      public void Dispose()
      {
         // Esse método é executado sempre que se chamar o método Dispose(); da classe ou sempre que se utilizar o using().
      }
   }
}

Espero que tenham entendido.

Até o próximo ;)

Posts Relacionados:

1. Desmistificando Interfaces