CodeGym /Cursos /C# SELF /Trabalho assíncrono com arquivos de texto

Trabalho assíncrono com arquivos de texto

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

1. Introdução

Lembre do nosso exemplo com o download de uma imagem grande. Enquanto ela carrega, a aplicação "trava". O mesmo acontece com arquivos de texto, especialmente se forem grandes (logs de dezenas de gigabytes, CSVs enormes, backups de banco de dados em formato de texto).

Imagine que você está escrevendo uma aplicação que:

Faz parsing de um log enorme para encontrar erros. Se você for ler ele de forma síncrona, a sua interface simplesmente "congela" por alguns segundos ou até minutos, até a operação terminar. O usuário vai achar que o programa quebrou.

Grava dados em um arquivo de relatório à medida que eles são gerados. Se a escrita bloquear a thread principal, tanto a geração dos dados quanto a interação com a UI vão sofrer.

Servidor web que precisa atender milhares de requisições. Cada requisição pode precisar ler ou gravar um arquivo. Se cada I/O de arquivo for síncrono, as threads do servidor vão ficar esperando o disco, e o servidor rapidamente vai "se afogar" com a carga.

Nesses cenários I/O assíncrono deixa de ser só uma "feature legal" e vira necessidade de vida. Ele permite que sua aplicação não fique parada enquanto o disco "pensa", e faça algo útil (por exemplo, atualizar a UI, processar outras requisições ou realizar cálculos).

Conceitos básicos: async/await e tasks

  • A palavra-chave async indica que o método pode conter "pontos de espera" (await).
  • O operador await temporariamente devolve o controle enquanto a tarefa assíncrona não termina (por exemplo, leitura de arquivo).
  • Um método assíncrono realiza I/O sem bloquear a thread atual: enquanto não há dados — a thread fica livre.

Tudo isso é a base da "mágica" assíncrona ao trabalhar com arquivos.

2. Métodos assíncronos para arquivos

Nas versões modernas do .NET praticamente todas as classes principais para trabalhar com arquivos têm equivalentes assíncronos. Para arquivos de texto você costuma usar:

  • StreamReader.ReadLineAsync()
  • StreamReader.ReadToEndAsync()
  • StreamWriter.WriteLineAsync()
  • StreamWriter.WriteAsync()
  • Também métodos estáticos: File.ReadAllTextAsync(), File.WriteAllTextAsync() e outros.
Leitura Gravação
ReadLineAsync()
WriteLineAsync()
ReadToEndAsync()
WriteAsync()
File.ReadAllXAsync()
File.WriteAllXAsync()

3. Leitura assíncrona de um arquivo de texto inteiro

Vamos ler o arquivo todo em uma string. Isso é feito para arquivos pequenos: configs, logs pequenos.

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

class Program
{
    static async Task Main()
    {
        string path = "input.txt";
        
        // Lemos o arquivo inteiro de forma assíncrona
        string fileContents = await File.ReadAllTextAsync(path);
        
        Console.WriteLine("Conteúdo do arquivo:");
        Console.WriteLine(fileContents);
    }
}

Repare: o método Main agora está marcado como async Task Main(). Isso é possível desde o C# 7.1. Um await — e tudo roda de forma assíncrona!

4. Leitura assíncrona linha a linha de um arquivo grande

Quando o arquivo é realmente grande, carregar tudo na memória não é uma boa ideia. Melhor ler linha a linha:

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

class Program
{
    static async Task Main()
    {
        string path = "biglog.txt";

        // Abrimos um StreamReader para leitura assíncrona
        using StreamReader reader = new StreamReader(path);

        string? line;
        while ((line = await reader.ReadLineAsync()) != null)
        {
            // Aqui você pode processar a linha (por exemplo, procurar erros)
            Console.WriteLine(line);
        }
    }
}

Como isso funciona?

Cada chamada de await reader.ReadLineAsync() libera a thread — especialmente útil se o arquivo estiver em um disco de rede ou na nuvem. Processamento assíncrono é crítico quando há dezenas de milhares de linhas e trabalho paralelo com usuários (por exemplo, em uma API de servidor).

5. Escrita assíncrona de linhas em arquivo

De forma similar, você pode gravar dados assíncronamente (por exemplo, ao gerar relatórios):

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

class Program
{
    static async Task Main()
    {
        string path = "output.txt";

        using StreamWriter writer = new StreamWriter(path);

        for (int i = 0; i < 5; i++)
        {
            await writer.WriteLineAsync($"Linha número {i + 1}");
        }
        
        // Você pode chamar FlushAsync explicitamente para garantir a gravação
        await writer.FlushAsync();

        Console.WriteLine("Dados gravados de forma assíncrona!");
    }
}

Chamar FlushAsync() nem sempre é obrigatório — ao fechar o StreamWriter o buffer será esvaziado. Mas se você precisa da garantia "agora mesmo", use ele.

6. Interação de múltiplas operações assíncronas de arquivo

Suponha que você precise ler um arquivo de texto e, em paralelo, escrever uma versão transformada em outro:

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

class Program
{
    static async Task Main()
    {
        string sourcePath = "even_biggerlog.txt";
        string destinationPath = "copy_biggerlog.txt";

        using StreamReader reader = new StreamReader(sourcePath);
        using StreamWriter writer = new StreamWriter(destinationPath);

        string? line;
        int linesProcessed = 0;

        while ((line = await reader.ReadLineAsync()) != null)
        {
            // Um pouco de mágica: transformamos todas as letras em maiúsculas
            string processed = line.ToUpperInvariant();

            await writer.WriteLineAsync(processed);
            linesProcessed++;
        }

        Console.WriteLine($"Linhas processadas: {linesProcessed}");
    }
}

Aqui leitura e escrita são feitas de forma assíncrona. Cada await libera o controle, permitindo que a aplicação faça outra coisa.

7. Aplicações práticas: onde isso é usado?

  • Desenvolvimento web (ASP.NET Core): upload/download de arquivos não bloqueia o processamento de outras requisições; o servidor continua responsivo.
  • Aplicações desktop (WPF, WinForms): ao abrir um log ou salvar um relatório a UI não "trava".
  • Engines de jogo: carregamento assíncrono de recursos (texturas, modelos) permite não interromper animações e gameplay.
  • Processamento de big data: parsing de grandes CSV/JSON/XML linha a linha, processamento "on the fly" sem uso excessivo de memória.
  • Serviços em background e daemons: logging, cache, processamento de filas com uso eficiente de threads e disco.

Resumo: assincronismo ajuda a criar aplicações modernas, responsivas e escaláveis. "Bloquear" é ruim, assincronismo é bom!

8. Nuances e boas práticas

Não esqueça de await! Se chamar um método com sufixo Async sem esperar, você vai receber um Task, mas o código vai seguir em frente, o que leva a erros de ordem de execução.

// RUIM: esquecemos o await
FileManager.ReadTextFileAsync("nonexistent.txt"); // vai iniciar, mas Main continua
Console.WriteLine("Eu executei imediatamente, embora o arquivo ainda esteja sendo lido (ou já tenha lançado erro)! Isso é ruim!");

O compilador geralmente avisa sobre await esquecido, mas não impede a build.

using para tudo que implementa IDisposable: todos os streams (FileStream, StreamReader, StreamWriter) devem ser liberados corretamente. Use blocos using ou declarações using (C# 8+) para garantir fechamento e flushing dos buffers.

Tamanho do buffer (bufferSize): StreamReader/StreamWriter já são otimizados, mas em casos especiais você pode experimentar. Por padrão são valores confortáveis (em FileStream frequentemente usam 4096 bytes).

Tratamento de erros: métodos assíncronos também lançam exceções. Envolva operações em try-catch. A exceção "vai subir" quando você fizer await sobre a Task correspondente.

ConfigureAwait: em bibliotecas e cenários web onde você não precisa do contexto de sincronização (GUI), use await SomeAsync().ConfigureAwait(false). Isso reduz overhead de troca de contexto. Em apps de console e UI normalmente pode ser omitido.

Pratique — e em breve async Task vai se tornar tão natural quanto Console.WriteLine.

9. Erros típicos e nuances importantes das operações assíncronas de arquivo

Se você não usar await (e simplesmente chamar um método com sufixo Async), vai receber um objeto Task, mas o resultado não será aguardado automaticamente. Você precisa esperar com await ou aguardar explicitamente (o que geralmente é indesejável).

Não se pode aguardar métodos assíncronos a partir de código síncrono sem "elevar" o async pela stack. Usar .Result ou .GetAwaiter().GetResult() pode causar deadlocks — é melhor transformar os métodos chamadores em async.

Não leia e não escreva o mesmo arquivo ao mesmo tempo (mesmo que assíncronamente). Isso pode causar race conditions e corromper dados.

Assincronismo libera a thread chamadora, mas não torna as operações mais rápidas: se o disco ou a rede forem lentos, assíncrono também será lento — só que sem bloquear a UI ou threads de trabalho.

2
Tarefa
C# SELF, nível 42, lição 2
Bloqueado
Leitura assíncrona de arquivo linha por linha
Leitura assíncrona de arquivo linha por linha
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION