CodeGym /Cursos /C# SELF /Tratamento de erros em operações assíncronas ( async/ awa...

Tratamento de erros em operações assíncronas ( async/ await)

C# SELF
Nível 42, Lição 3
Disponível

1. Introdução

Vamos começar com uma pergunta importante: por que não dá pra simplesmente confiar nos métodos assíncronos e esperar que tudo sempre funcione direitinho? Operações com arquivos frequentemente lançam exceções — o arquivo pode ter sido deletado, pode ter acabado memória, faltar permissão ou o arquivo estar bloqueado. No código síncrono você pegaria os problemas no seu habitual bloco try-catch. No código assíncrono a filosofia é a mesma, mas tem nuances: o erro pode acontecer não imediatamente na chamada do método, mas mais tarde, quando a operação realmente for executada.

Momento de ocorrência do erro

No código síncrono ao ler com StreamReader.Read() a exceção vai saltar direto na linha da chamada — você pega no catch, tranquilo.
No código assíncrono (await stream.ReadAsync()) o erro vai cair não na hora do início da operação, mas justamente no await — quando a Task terminar com erro. Se esquecer de colocar o await, a exceção pode ficar “invisível” por um tempo.

2. Como capturar exceções em métodos assíncronos

Vamos ver logo o template típico:


try
{
    using FileStream fs = new FileStream("myfile.txt", FileMode.Open);
    byte[] buffer = new byte[1024];
    int bytesRead = await fs.ReadAsync(buffer, 0, buffer.Length);
    // Processamento adicional...
}
catch (IOException ex)
{
    Console.WriteLine("Erro de I/O: " + ex.Message);
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Sem acesso ao arquivo: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Erro desconhecido: " + ex);
}

Isso mesmo, é simples — usamos o conhecido try-catch, mas dentro de um método assíncrono. Importante que o próprio método tenha a palavra-chave async, senão o compilador vai reclamar.

Nuance importante: onde colocar o await


Task<int> readTask = fs.ReadAsync(buffer, 0, buffer.Length);
// ... aqui acidentalmente esquecemos o await ou o tratamento

Nesse caso a exceção, se acontecer, vai morar dentro da própria Task (Task), e você só vai saber dela quando tentar obter o resultado — por exemplo, com await readTask ou pela propriedade Task.Exception. Se esquecer totalmente do await — a Task pode falhar e ninguém vai te avisar.

3. Por que código assíncrono sem tratamento é traiçoeiro

Cenário 1: “Fire and forget” — armadilha de iniciante


FileStream fs = new FileStream("file.txt", FileMode.Open);
byte[] buffer = new byte[8000];
fs.ReadAsync(buffer, 0, buffer.Length);
// E o programa segue a vida dele

A operação de leitura vai nadar por conta própria, e se ela terminar com erro, nenhum catch vai pegá-la. A exceção fica escondida dentro da Task. Esse padrão é chamado “fire and forget” e em apps reais pode causar perda de erros críticos e vazamento de recursos.

Cenário 2: Métodos assíncronos sem await


Task t = MyAsyncMethod();
// ... faz algo aqui, e depois esquece do t

Erros que acontecerem dentro de MyAsyncMethod não vão subir até você enquanto você não esperar explicitamente pela Task (await t ou t.Wait()).

4. Como corretamente capturar erros vindos de Tasks assíncronas

Estratégia 1: Sempre use await


try
{
    await SomeFileOperationAsync();
}
catch (Exception ex)
{
    Console.WriteLine("Algo deu errado: " + ex.Message);
}

Assim a exceção vai ser lançada exatamente no ponto do await e não se perderá.

Estratégia 2: Tratamento com .ContinueWith

Se por algum motivo você não quer usar await, dá pra adicionar um handler de erro com ContinueWith:


var task = fs.ReadAsync(buffer, 0, buffer.Length);
task.ContinueWith(t =>
{
    if (t.Exception != null)
        Console.WriteLine("Erro na leitura assíncrona: " + t.Exception.InnerException);
}, TaskContinuationOptions.OnlyOnFaulted);

Sinceramente? Em apps modernos em C# isso é pouco usado — async/await deixa o código mais simples e mais limpo.

Exceções possíveis ao trabalhar com arquivos de forma assíncrona

5. Exemplo: leitura assíncrona com tratamento de erros

Vamos adicionar essa lógica no nosso app:


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

namespace FileAsyncDemo
{
    class Program
    {
        static async Task Main()
        {
            string path = "bigfile.txt";
            byte[] buffer = new byte[4096];

            try
            {
                using FileStream fs = new FileStream(path, FileMode.Open);
                int bytesRead = await fs.ReadAsync(buffer, 0, buffer.Length);
                Console.WriteLine($"Lido {bytesRead} bytes de {path}");
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine("Arquivo não encontrado: " + ex.Message);
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine("Sem acesso ao arquivo: " + ex.Message);
            }
            catch (IOException ex)
            {
                Console.WriteLine("Erro de leitura/gravação: " + ex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Outro erro: " + ex.Message);
            }
        }
    }
}

Observação importante

Se você não usar await no Main, e fizer só Task result = SomeAsyncMethod(); — as exceções vão “calar a boca” e só aparecer quando você finalmente tentar obter o resultado.

6. Erros mais comuns e “cascas de banana” no tratamento

Esquecer de colocar await em um método assíncrono — as exceções não sobem na hora, o programa se comporta de forma imprevisível.

Não envolver chamadas assíncronas em try-catch — o app cai no primeiro erro.

Tratar só Exception, ignorando exceções específicas como UnauthorizedAccessException ou OperationCanceledException — acaba com diagnósticos ruins.

Usar tarefas “fire and forget” sem logging explícito — as exceções se perdem dentro da Task.

Pensar que se a Task terminou então tudo deu certo. É preciso esperar explicitamente o resultado (await) e tratar exceções.

2
Tarefa
C# SELF, nível 42, lição 3
Bloqueado
Tratamento de erro ao ler um arquivo
Tratamento de erro ao ler um arquivo
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION