IDisposable e a Instrução using

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy. Lição 45 de 70.

Alguns objetos mantêm recursos que o coletor de lixo não consegue limpar automaticamente — identificadores de arquivo, conexões de banco de dados e sockets de rede. A interface IDisposable fornece uma maneira padrão de liberar esses recursos quando você terminar de usá-los.

Uma classe implementa IDisposable fornecendo um método Dispose():

public class FileHandler : IDisposable
{
    private bool disposed = false;
    
    public void Dispose()
    {
        if (!disposed)
        {
            Console.WriteLine("Releasing resources...");
            disposed = true;
        }
    }
}

Você poderia chamar Dispose() manualmente, mas e se ocorrer uma exceção antes de você chegar a essa linha? A instrução using garante que a limpeza aconteça, mesmo quando as coisas dão errado:

using (FileHandler handler = new FileHandler())
{
    // Trabalhe com o handler
}  // Dispose() chamado automaticamente aqui

O C# moderno oferece uma sintaxe mais limpa com a declaração using, que descarta o objeto quando ele sai do escopo:

void ProcessFile()
{
    using FileHandler handler = new FileHandler();
    // Trabalhe com o handler
}  // Dispose() é chamado quando o método sai

A instrução using funciona com qualquer tipo que implemente IDisposable. Classes integradas, como StreamReader, SqlConnection e HttpClient, todas implementam essa interface, tornando o gerenciamento adequado de recursos simples e confiável.

Desafio

Fácil

Vamos criar um simulador de conexão com banco de dados que demonstra o gerenciamento adequado de recursos usando a interface IDisposable e a instrução using. Você criará uma classe que rastreia quando as conexões são abertas e fechadas, garantindo que os recursos sejam sempre liberados corretamente.

Você organizará seu código em dois arquivos:

DatabaseConnection.cs: crie uma classe DatabaseConnection no namespace DataAccess que implemente IDisposable. Sua conexão deve:
- Ter uma propriedade ConnectionName (string, somente leitura) definida por meio do construtor
- Rastrear se a conexão foi descartada usando um campo booleano privado
- Imprimir Connection opened: {ConnectionName} quando o objeto for criado (no construtor)
- Implementar o método Dispose() para imprimir Connection closed: {ConnectionName} — mas somente se ainda não tiver sido descartada (evitando o descarte duplicado)
- Ter um método Query(string sql) que retorne Executing on {ConnectionName}: {sql}
Program.cs: no arquivo principal, demonstre o gerenciamento adequado de recursos usando a instrução using com sua conexão de banco de dados. Crie uma conexão, execute uma consulta e deixe o bloco using cuidar da limpeza automaticamente.

Você receberá duas entradas:

O nome da conexão (por exemplo, MainDB)
A consulta SQL a ser executada (por exemplo, SELECT * FROM Users)

Use uma instrução using para criar sua conexão. Dentro do bloco, chame o método Query e imprima o resultado. Quando o bloco using terminar, Dispose() será chamado automaticamente.

Por exemplo, se as entradas forem MainDB e SELECT * FROM Users, a saída deverá ser:

Connection opened: MainDB
Executing on MainDB: SELECT * FROM Users
Connection closed: MainDB

Observe como a conexão é fechada automaticamente quando o bloco using termina — você nunca precisa se lembrar de chamar Dispose() manualmente. Esse padrão garante que os recursos sejam sempre liberados, mesmo que ocorra uma exceção dentro do bloco!

Experimente você mesmo

using System;
using DataAccess;

class Program
{
    public static void Main(string[] args)
    {
        string connectionName = Console.ReadLine();
        string sqlQuery = Console.ReadLine();
        
        // TODO: Use uma instrução 'using' para criar um DatabaseConnection
        // Dentro do bloco using:
        // 1. Chame o método Query com o sqlQuery
        // 2. Imprima o resultado do método Query
        // O método Dispose será chamado automaticamente quando o bloco using terminar
        
    }
}