C# using e IDisposable

Na aula finally, a Ana perdeu a lista de compras porque o arquivo não foi fechado, e consertou com um try/finally. Funciona, mas são oito linhas para dizer "feche quando terminar". O C# tem um atalho para isso: o comando using. Nesta aula você vai usá-lo nas duas formas (com bloco e a declaração using var), entender a interface IDisposable que está por trás e criar uma classe sua que pode ser usada com using.

Todos os programas rodaram na máquina da Ana, com o .NET 10 (C# 14), usando dotnet run arquivo.cs na pasta ~/cs.

A ideia antes do código

A Ana pegou um livro emprestado na biblioteca da escola. O combinado é simples: usou, devolveu. Se ela esquecer, ninguém mais consegue pegar aquele livro, e no fim do ano a biblioteca está vazia. Melhor ainda seria um empréstimo que se devolvesse sozinho quando ela terminasse de ler.

No computador, as coisas "emprestadas" se chamam recursos: um arquivo aberto, uma conexão com um banco de dados, uma conexão de rede. O sistema operacional empresta e espera de volta. Um programa que abre arquivos e não fecha acaba sem poder abrir mais nenhum, e os dados que estavam esperando no buffer (como na aula finally) se perdem.

O using é o empréstimo que se devolve sozinho: você diz o que vai usar, e o C# garante que, no fim, aquilo é devolvido, dando certo ou dando errado.

1. O bloco using

using (var escritor = new StreamWriter("compras.txt"))
{
    escritor.WriteLine("arroz");
    escritor.WriteLine("feijão");
}
Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));

$ dotnet run bloco.cs
No arquivo:
arroz
feijão

using (

O comando using ("usando"): "enquanto eu estiver usando isto…".

var escritor = new StreamWriter("compras.txt")

Abre o recurso e guarda numa variável, como sempre. A variável só existe dentro do bloco.

{ … }

O bloco em que o recurso é usado.

} (o fim do bloco)

Aqui o C# chama escritor.Dispose() sozinho. Para um StreamWriter, Dispose() grava o que estava no buffer e fecha o arquivo, o mesmo que o Close().

Depois do bloco, o arquivo já está fechado e gravado: o File.ReadAllText (aula Arquivos) lê as duas linhas.

O que o compilador faz com o using

O using não é mágica: o compilador o transforma no try/finally que você já conhece. As duas versões abaixo são o mesmo programa:

using (var escritor = new StreamWriter("compras.txt"))
{
    escritor.WriteLine("arroz");
}

var escritor = new StreamWriter("compras.txt");
try
{
    escritor.WriteLine("arroz");
}
finally
{
    escritor?.Dispose();
}

Por isso o using herda todas as garantias do finally: o Dispose() roda no fim do bloco, com return, com break e com exceção.

var escritor = new StreamWriter("compras.txt");
escritor.WriteLine("arroz");
escritor.WriteLine("feijão");

Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));

using (var escritor = new StreamWriter("compras.txt"))
{
    escritor.WriteLine("arroz");
    escritor.WriteLine("feijão");
}

Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));

2. A interface IDisposable

Como o using sabe o que fazer no fim? Ele não sabe: ele só chama Dispose(). Quem sabe o que significa "devolver" é a própria classe. Toda classe que guarda um recurso assina um contrato, a interface IDisposable ("descartável"), que tem um método só:

public interface IDisposable
{
    void Dispose();
}

StreamWriter, StreamReader, FileStream, as conexões de banco de dados e muitas outras classes implementam IDisposable. Uma classe sua também pode. O caixa da lojinha abre no construtor e fecha no Dispose():

try
{
    using (var caixa = new Caixa())
    {
        caixa.Vender(10m);
        caixa.Vender(-5m);
        caixa.Vender(20m);
    }
}
catch (ArgumentOutOfRangeException e)
{
    Console.WriteLine($"Erro: {e.Message}");
}
Console.WriteLine("Fim");

class Caixa : IDisposable
{
    public Caixa()
    {
        Console.WriteLine("Abrindo o caixa");
    }

    public void Vender(decimal valor)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(valor);
        Console.WriteLine($"Venda: {valor:C}");
    }

    public void Dispose()
    {
        Console.WriteLine("Fechando o caixa");
    }
}

$ dotnet run caixa.cs
Abrindo o caixa
Venda: R$ 10,00
Fechando o caixa
Erro: valor ('-5') must be a non-negative value. (Parameter 'valor')
Actual value was -5.
Fim

class Caixa : IDisposable

A classe promete ter um método public void Dispose(). É essa promessa que permite usá-la num using.

public void Dispose()

O que "devolver" quer dizer para um Caixa. Aqui, só uma mensagem; num programa de verdade, fechar arquivos ou conexões que a classe abriu.

caixa.Vender(-5m);

Lança ArgumentOutOfRangeException (o atalho ThrowIfNegative, da aula throw). A venda de 20 nunca acontece.

Fechando o caixa

Aparece antes do Erro:. A exceção, ao sair do bloco using, passou pelo finally escondido, que chamou Dispose(). Só depois ela chegou ao catch, lá fora.

using (var caixa = new Caixa())
{
    caixa.Vender(10m);
}
Console.WriteLine("Fim");

class Caixa
{
    public Caixa()
    {
        Console.WriteLine("Abrindo o caixa");
    }

    public void Vender(decimal valor)
    {
        Console.WriteLine($"Venda: {valor:C}");
    }
}

using (var caixa = new Caixa())
{
    caixa.Vender(10m);
}
Console.WriteLine("Fim");

class Caixa : IDisposable
{
    public Caixa()
    {
        Console.WriteLine("Abrindo o caixa");
    }

    public void Vender(decimal valor)
    {
        Console.WriteLine($"Venda: {valor:C}");
    }

    public void Dispose()
    {
        Console.WriteLine("Fechando o caixa");
    }
}

3. A declaração using var C# 8

O bloco using obriga a abrir chaves e recuar o código. Desde o C# 8, há uma forma sem bloco: using na frente da declaração da variável. O recurso é liberado quando a variável sai de escopo, isto é, no fim do bloco em que ela foi declarada (o método, o if, o laço…):

Gravar("compras.txt");
Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));

void Gravar(string caminho)
{
    using var escritor = new StreamWriter(caminho);
    escritor.WriteLine("arroz");
    escritor.WriteLine("feijão");
}

$ dotnet run metodo.cs
No arquivo:
arroz
feijão

using var escritor = new StreamWriter(caminho);

Abre o arquivo e marca a variável para Dispose() automático.

} (o fim do método Gravar)

A variável sai de escopo e o arquivo é fechado. Quando o File.ReadAllText roda, tudo já está gravado.

É a forma que o guia usa com arquivos (aula StreamReader e StreamWriter): curta, e impossível de esquecer, porque o fechamento fica na mesma linha da abertura.

A armadilha: using var nas instruções do topo

Nas instruções de nível superior, o "bloco" é o programa inteiro. Um using var escrito ali só é liberado quando o programa termina:

using var escritor = new StreamWriter("compras.txt");
escritor.WriteLine("arroz");
escritor.WriteLine("feijão");
Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));
Console.WriteLine("(fim)");

$ dotnet run declaracao.cs
No arquivo:
(fim)
$ cat compras.txt
arroz
feijão

Durante o programa, o arquivo estava vazio: o escritor ainda estava aberto, com as linhas no buffer. Elas só foram gravadas no fim, depois do (fim), quando o Dispose() rodou; por isso o cat as mostra. Nada se perdeu, mas o próprio programa leu o arquivo cedo demais. A solução é dar ao escritor um escopo menor: um bloco using (…) { } ou um método, como o Gravar acima.

4. Vários recursos: fechados de trás para frente

using var gaveta = new Recurso("gaveta");
using var cofre = new Recurso("cofre");
Console.WriteLine("Trabalhando...");

class Recurso : IDisposable
{
    private readonly string _nome;
    public Recurso(string nome)
    {
        _nome = nome;
        Console.WriteLine($"Abrindo {_nome}");
    }
    public void Dispose() => Console.WriteLine($"Fechando {_nome}");
}

$ dotnet run dois.cs
Abrindo gaveta
Abrindo cofre
Trabalhando...
Fechando cofre
Fechando gaveta

Quem abriu por último fecha primeiro, como uma pilha de pratos. Faz sentido: o segundo recurso pode depender do primeiro (um leitor que lê de um arquivo aberto antes, por exemplo), então o primeiro tem de continuar aberto até o segundo terminar.

Formas diferentes, qual usar

Quando dá errado

using (var lista = new List<string>())
{
    lista.Add("arroz");
}

$ dotnet run naodisp.cs
/home/ana/cs/naodisp.cs(1,8): error CS1674: 'List<string>': o tipo usado em uma instrução 'using' deve implementar 'System.IDisposable'.

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

var escritor = new StreamWriter("compras.txt");
using (escritor)
{
    escritor.WriteLine("arroz");
}
escritor.WriteLine("feijão");

$ dotnet run fechado.cs
Unhandled exception. System.ObjectDisposedException: Cannot write to a closed TextWriter.
Object name: 'StreamWriter'.
   at System.IO.StreamWriter.<ThrowIfDisposed>g__ThrowObjectDisposedException|80_0()
   at System.IO.StreamWriter.WriteLine(String value)
   at Program.<Main>$(String[] args) in /home/ana/cs/fechado.cs:line 6

Referência

Exercícios

using var escritor = new StreamWriter("compras.txt");
escritor.WriteLine("arroz");
escritor.WriteLine("feijão");
Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));
Console.WriteLine("(fim)");

using (var escritor = new StreamWriter("compras.txt"))
{
    escritor.WriteLine("arroz");
    escritor.WriteLine("feijão");
}
Console.WriteLine("No arquivo:");
Console.Write(File.ReadAllText("compras.txt"));
Console.WriteLine("(fim)");

Resumo

• Recursos (arquivos, conexões) são emprestados pelo sistema e precisam ser devolvidos. Quem devolve é o método Dispose() da interface IDisposable.
• using (var x = …) { … } chama Dispose() no fim do bloco, com ou sem exceção. Por baixo, é um try/finally.
• using var x = …; C# 8 chama Dispose() no fim do bloco onde a variável foi declarada. Nas instruções do topo, isso é o fim do programa.
• Vários recursos são fechados na ordem inversa da abertura.
• Uma classe sua pode implementar IDisposable; faça isso quando ela guardar outro recurso IDisposable.
• CS1674: o tipo não é IDisposable. ObjectDisposedException: usou depois de fechar.