Leitura Eficiente de Arquivos de Texto Linha por Linha em C#

Ler arquivos de texto de forma eficiente, linha por linha, é uma habilidade crucial para qualquer desenvolvedor C#. Seja processando logs, analisando arquivos de configuração ou conjuntos de dados, o método escolhido pode impactar significativamente o desempenho e o uso de recursos. Este artigo explora três abordagens comuns, destacando seus pontos fortes e fracos para ajudar você a selecionar a técnica ideal para suas necessidades específicas.

Sumário

• Usando File.ReadLines()
• Usando File.ReadAllLines()
• Usando StreamReader.ReadLine()
• Escolhendo o Método Certo

Usando File.ReadLines()

O método File.ReadLines() é geralmente a opção mais eficiente e conveniente, especialmente para arquivos grandes. Ele retorna um IEnumerable, o que significa que ele processa o arquivo linha por linha sem carregar todo o conteúdo na memória de uma só vez. Esse carregamento preguiçoso previne potenciais erros OutOfMemoryException ao lidar com conjuntos de dados massivos.

using System;
using System.IO;
using System.Linq;

public class ReadLinesExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt"; 

        try
        {
            foreach (string line in File.ReadLines(filePath))
            {
                Console.WriteLine(line); 
                //Processar cada linha aqui
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Arquivo não encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocorreu um erro: {ex.Message}");
        }
    }
}

Usando File.ReadAllLines()

File.ReadAllLines() oferece uma sintaxe mais simples, lendo todas as linhas em um array de strings. No entanto, essa abordagem carrega todo o arquivo na memória, tornando-o ineficiente e potencialmente problemático para arquivos grandes. É mais adequado para arquivos menores onde o consumo de memória não é uma preocupação importante.

using System;
using System.IO;

public class ReadAllLinesExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt";

        try
        {
            string[] lines = File.ReadAllLines(filePath);
            foreach (string line in lines)
            {
                Console.WriteLine(line); 
                //Processar cada linha aqui
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Arquivo não encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocorreu um erro: {ex.Message}");
        }
    }
}

Usando StreamReader.ReadLine()

StreamReader.ReadLine() fornece o controle mais granular. Você lê uma linha por vez usando um loop, permitindo o processamento personalizado de cada linha antes de ler a próxima. Este método requer gerenciamento explícito de recursos usando uma instrução using para garantir a eliminação adequada do StreamReader.

using System;
using System.IO;

public class StreamReaderExample
{
    public static void Main(string[] args)
    {
        string filePath = "myFile.txt";

        try
        {
            using (StreamReader reader = new StreamReader(filePath))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    Console.WriteLine(line); 
                    //Processar cada linha aqui
                }
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Arquivo não encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocorreu um erro: {ex.Message}");
        }
    }
}

Escolhendo o Método Certo

Para a maioria dos cenários, especialmente ao lidar com arquivos grandes, File.ReadLines() é a abordagem recomendada devido à sua eficiência e facilidade de uso. File.ReadAllLines() é adequado apenas para arquivos menores. StreamReader.ReadLine() fornece mais controle, mas exige um gerenciamento de recursos mais cuidadoso.

Lembre-se de sempre incluir tratamento de erros robusto para gerenciar com elegância possíveis exceções, como erros de arquivo não encontrado.