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 implements 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 acompanha 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 implements IDisposable. Sua conexão deve:
- Ter uma propriedade ConnectionName (string, somente leitura) definida por meio do constructor
- Acompanhar se a conexão foi disposed usando um campo booleano private
- Print Connection opened: {ConnectionName} quando o objeto for create (no constructor)
- Implement o método Dispose() para print Connection closed: {ConnectionName} — mas only se ainda não tiver sido disposed (prevent descarte duplo)
- Ter um método Query(string sql) que retorna Executing on {ConnectionName}: {sql}
Program.cs: no seu 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 lidar automaticamente com a limpeza.

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 create sua conexão. Inside do bloco, chame o método Query e print o resultado. Quando o bloco using ends, 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 é automaticamente fechada quando o bloco using ends — você nunca precisa se lembrar de chamar Dispose() manualmente. Esse padrão garante que os recursos sejam sempre limpos, mesmo que ocorra uma exceção Inside 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
        
    }
}