Lectura eficiente de archivos de texto línea por línea en C#

Leer archivos de texto de forma eficiente línea por línea es una habilidad crucial para cualquier desarrollador C#. Ya sea que esté procesando registros, analizando archivos de configuración o analizando conjuntos de datos, el método que elija puede afectar significativamente el rendimiento y el uso de recursos. Este artículo explora tres enfoques comunes, destacando sus fortalezas y debilidades para ayudarlo a seleccionar la técnica óptima para sus necesidades específicas.

Tabla de contenido

• Usando File.ReadLines()
• Usando File.ReadAllLines()
• Usando StreamReader.ReadLine()
• Eligiendo el método correcto

Usando File.ReadLines()

El método File.ReadLines() es generalmente la opción más eficiente y conveniente, especialmente para archivos grandes. Devuelve un IEnumerable, lo que significa que procesa el archivo línea por línea sin cargar todo el contenido en memoria a la vez. Esta carga diferida evita posibles errores OutOfMemoryException cuando se trata de conjuntos de datos masivos.

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); 
                //Procesar cada línea aquí
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Archivo no encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocurrió un error: {ex.Message}");
        }
    }
}

Usando File.ReadAllLines()

File.ReadAllLines() ofrece una sintaxis más simple, leyendo todas las líneas en una matriz de cadenas. Sin embargo, este enfoque carga todo el archivo en memoria, lo que lo hace ineficiente y potencialmente problemático para archivos grandes. Es más adecuado para archivos más pequeños donde el consumo de memoria no es una preocupación 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); 
                //Procesar cada línea aquí
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Archivo no encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocurrió un error: {ex.Message}");
        }
    }
}

Usando StreamReader.ReadLine()

StreamReader.ReadLine() proporciona el control más granular. Lee una línea a la vez usando un bucle, permitiendo el procesamiento personalizado de cada línea antes de leer la siguiente. Este método requiere una gestión explícita de recursos usando una instrucción using para asegurar la eliminación adecuada del 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); 
                    //Procesar cada línea aquí
                }
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Archivo no encontrado: {filePath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ocurrió un error: {ex.Message}");
        }
    }
}

Eligiendo el método correcto

Para la mayoría de los escenarios, especialmente cuando se trata de archivos grandes, File.ReadLines() es el enfoque recomendado debido a su eficiencia y facilidad de uso. File.ReadAllLines() solo es adecuado para archivos más pequeños. StreamReader.ReadLine() proporciona más control pero exige una gestión de recursos más cuidadosa.

Recuerde incluir siempre un manejo de errores robusto para gestionar con elegancia posibles excepciones como errores de archivo no encontrado.