Dica C#: Asynchronous Disposable

Vamos falar sobre Asynchronous Disposable, introduzido no C# 8, que permite liberar recursos de forma assíncrona, útil em cenários onde a liberação de recursos pode levar algum tempo. Isso é particularmente importante em aplicações que lidam com recursos como conexões de banco de dados, arquivos ou streams de rede, que frequentemente precisam ser fechados de forma adequada. Veja o exemplo no código abaixo.

using System;
using System.IO;
using System.Threading.Tasks;

public class ArquivoAsync : IAsyncDisposable
{
    private readonly FileStream _fileStream;

    public ArquivoAsync(string caminho)
    {
        _fileStream = new FileStream(caminho, FileMode.OpenOrCreate);
    }

    public async Task EscreverAsync(string conteudo)
    {
        byte[] dados = System.Text.Encoding.UTF8.GetBytes(conteudo);
        await _fileStream.WriteAsync(dados, 0, dados.Length);
    }

    public async ValueTask DisposeAsync()
    {
        await _fileStream.DisposeAsync(); // Liberação assíncrona dos recursos
    }
}

public class Program
{
    public static async Task Main()
    {
        // Usando "await using" para garantir que os recursos sejam liberados de forma assíncrona
        await using (var arquivo = new ArquivoAsync("arquivo.txt"))
        {
            await arquivo.EscreverAsync("Conteúdo assíncrono");
        }
        // Aqui o recurso será liberado de forma assíncrona, sem bloquear o restante do código
        Console.WriteLine("Arquivo gravado e recursos liberados.");
    }
}

Explicação: Em aplicações modernas, muitas vezes trabalhamos com recursos que precisam ser liberados assim que o trabalho termina. Tradicionalmente, usamos a interface IDisposable para liberar esses recursos de maneira síncrona, o que é eficiente para operações rápidas. No entanto, em cenários onde a liberação de recursos pode ser demorada, como ao fechar conexões de rede ou escrever grandes quantidades de dados em um arquivo, a liberação síncrona pode bloquear o aplicativo, afetando a performance.

Aqui entra o Asynchronous Disposable, que permite liberar esses recursos de maneira assíncrona. Ao implementar a interface IAsyncDisposable, você pode liberar recursos sem bloquear o restante da aplicação. Isso se encaixa perfeitamente em cenários onde há operações que demoram a ser finalizadas, como escrever em arquivos grandes ou fechar conexões de rede ou banco de dados.

No exemplo acima, mostramos como criar uma classe que escreve em um arquivo de forma assíncrona e libera os recursos usando DisposeAsync.

Código fonte: GitHub

Espero que essa dica ajude você! Até a próxima.