CodeGym /Cursos /C# SELF /Lectura de archivos de texto: StreamReader

Lectura de archivos de texto: StreamReader

C# SELF
Nivel 36, Lección 2
Disponible

1. Introducción

Imagina que otra vez tienes la tarea de leer el contenido de un archivo de texto. Supón que tienes un archivo con citas útiles de programadores que quieres mostrar en tu ya conocido programa de texto. Sí, ya hemos visto métodos de alto nivel como File.ReadAllText, pero ¿y si el archivo es grande y necesitas leerlo línea por línea? ¿O quieres leer el archivo de forma controlada, por ejemplo, cargando las líneas poco a poco para no petar la memoria?

Aquí es donde StreamReader viene al rescate — una clase perfecta para leer archivos de texto línea por línea, por bloques, carácter a carácter — vamos, súper flexible y cómoda.

¿Cómo funciona StreamReader?

StreamReader es una clase del espacio de nombres System.IO que implementa la lectura de datos de texto desde un stream (normalmente un archivo, pero también puede ser un stream de red o de memoria). Sabe leer datos en la codificación que quieras, los convierte en caracteres y líneas, y te devuelve tipos de datos cómodos: strings y chars.

Si lo dibujamos como un esquema, sería algo así:


[ Archivo (bytes) ] --(FileStream)--> [ StreamReader (convierte códigos de caracteres) ] ---> [ Tu código (string, char) ]
  • Archivo (u otra fuente de bytes): Nos da los bytes.
  • FileStream: Lee esos bytes como un "canal".
  • StreamReader: Convierte los bytes en caracteres y líneas según la codificación (por defecto — UTF-8).

¿Por qué no siempre deberías usar solo File.ReadAllText?

En la práctica, los archivos pueden ser grandes. Muy grandes (por ejemplo, logs o csv con un millón de líneas). Intentar leer esos archivos enteros en memoria es como intentar comerte toda la tarta de una vez: rico, pero peligroso para la salud.
StreamReader lee el archivo "a trozos". No carga todo el archivo en memoria, sino que va trayendo y devolviendo la siguiente línea o carácter solo cuando lo necesitas. Es eficiente y muy cómodo.

2. Leer un archivo completo línea por línea

Vamos a crear un archivo quotes.txt con estas líneas:


El código es poesía.
Debuggear es ser detective.
"No funciona" — el mejor bug report.

Ahora añadimos el código a nuestra aplicación de práctica (que sea una app de consola sencilla que vamos mejorando poco a poco). Ponemos el archivo al lado del .exe — que el programa lo lea y muestre el contenido línea por línea.

Código con comentarios:


// Obtenemos la ruta al archivo en la carpeta del programa
string fileName = "quotes.txt";
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);

// Comprobamos si el archivo existe
if (!File.Exists(filePath))
{
    Console.WriteLine($"Archivo no encontrado: {filePath}");
    return;
}

// Abrimos el archivo para leer usando StreamReader
using StreamReader reader = new StreamReader(filePath);
string? line;
int lineNumber = 1;

// Leemos el archivo línea por línea hasta el final
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine($"{lineNumber,2}: {line}");
    lineNumber++;
}

¿Qué pasa aquí?

  • Calculamos la ruta a nuestro archivo usando Path.Combine y AppDomain.CurrentDomain.BaseDirectory — así el código funciona igual en Windows, Linux e incluso en un contenedor Docker.
  • Primero comprobamos que el archivo realmente existe.
  • Con using creamos el StreamReader y leemos el archivo línea a línea (método ReadLine()).
  • Al final del bloque using el archivo se cierra, aunque se te olvide hacerlo a mano o pilles una excepción.

Visualización: esquema de funcionamiento


[ quotes.txt ] --(FileStream)--> [ StreamReader ] --(ReadLine)--> [ string line ] --(Console.WriteLine)--> Pantalla
    ^                                                       
    |
AppDomain.CurrentDomain.BaseDirectory + Path.Combine

3. Detalles y matices de uso

Cómo se leen las líneas

El método ReadLine() devuelve la línea hasta el primer carácter de nueva línea (\n o \r\n). Cuando el archivo termina, devuelve null. Por eso el bucle suele ser así:


string? line;
while ((line = reader.ReadLine()) != null)
{
    // procesar la línea
}

Errores típicos al usar StreamReader

A veces da pereza usar using y escribes algo así:


StreamReader reader = new StreamReader(filePath);
// ...
reader.Close();

Eso es como olvidarte de cerrar la puerta en invierno: puede pasar cualquier cosa. Si durante la lectura hay un error (por ejemplo, de repente se pierde acceso al disco), el código para cerrar el archivo no se ejecuta y el archivo se queda abierto en el sistema.
Por eso usar using no es una recomendación, es una necesidad real. Tu futuro colega sysadmin te lo agradecerá porque tu programa no deja un zoo de archivos "colgados".

Versión corta usando using declaration

Con las versiones modernas de C# (desde la 8.0) puedes escribirlo más corto:


using StreamReader reader = new StreamReader(filePath);
string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine(line);
}

Dispose se llama al final del bloque actual (del método).

4. Trucos útiles

Leer un archivo con codificación desconocida

Por defecto StreamReader usa UTF-8. Pero a veces hay archivos con otra codificación (por ejemplo, Windows-1251 para textos antiguos en ruso). En ese caso, el programa puede mostrar "?" o caracteres raros.

Puedes especificar la codificación explícitamente:


using System.Text;

// Abrimos el archivo como Windows-1251
using StreamReader reader = new StreamReader(filePath, Encoding.GetEncoding("windows-1251"));

Documentación sobre codificaciones y Encoding

Leer el archivo como un solo texto grande

A veces necesitas obtener todo el archivo como un solo texto, pero no usando File.ReadAllText, sino con StreamReader.


using StreamReader reader = new StreamReader(filePath);
string allText = reader.ReadToEnd();
Console.WriteLine(allText);
  • El método ReadToEnd() lee todo el contenido del archivo desde la posición actual hasta el final como un solo string.
  • Para archivos grandes puede ser ineficiente y hay riesgo de OutOfMemoryException. Para archivos de hasta unos megas — va bien.

Cómo se usa esto en la vida real

  • Procesar logs. Si tienes un archivo de logs de servidor, es cómodo leerlo línea por línea, filtrar los eventos que te interesan y no cargar todo en memoria de golpe.
  • Importar CSV. Si necesitas parsear tablas grandes, es cómodo sacar los datos línea a línea y procesarlos según llegan.
  • Buscar palabras clave en archivos de texto grandes. Puedes buscar el texto que quieras entre millones de líneas sin miedo a quedarte sin memoria.
  • Tests unitarios. Los archivos con datos de test a menudo se leen línea por línea usando StreamReader.

Comparación de métodos de lectura

Método Cuándo usar Ventajas Desventajas
File.ReadAllText
Archivos pequeños Una línea de código, rápido Archivo grande = mucha memoria
StreamReader.ReadLine()
Cualquiera, sobre todo archivos grandes Lectura por líneas, poca memoria Un poco más de código, lógica más compleja
StreamReader.ReadToEnd()
Archivos pequeños/medianos Puedes controlar la codificación Chungo con archivos muy grandes

5. Práctica

Vamos a complicar el ejercicio. Que nuestro programa muestre solo las primeras N líneas del archivo, el número lo mete el usuario. A veces no quieres ver cientos de líneas de golpe — con un par de citas ya te motivas. :)

Así se hace:


using System;
using System.IO;

class Program
{
    static void Main()
    {
        string fileName = "quotes.txt";
        string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);

        if (!File.Exists(filePath))
        {
            Console.WriteLine($"Archivo no encontrado: {filePath}");
            return;
        }

        Console.Write("¿Cuántas líneas mostrar? ");
        string? input = Console.ReadLine();
        if (!int.TryParse(input, out int linesToShow) || linesToShow < 1)
        {
            Console.WriteLine("Error: Introduce un número correcto mayor que 0.");
            return;
        }

        using StreamReader reader = new StreamReader(filePath);

        int current = 0;
        string? line;
        while (current < linesToShow && (line = reader.ReadLine()) != null)
        {
            Console.WriteLine(line);
            current++;
        }

        if (current == 0)
            Console.WriteLine("El archivo está vacío o no se pudo leer la primera línea.");
        else if (current < linesToShow)
            Console.WriteLine($"El archivo solo tenía {current} línea(s).");
    }
}

6. Cosas importantes y trampas típicas

Cuando trabajas con StreamReader, lo principal es acordarte de gestionar bien los recursos (ver la lección anterior sobre IDisposable). Si te olvidas, puedes tener el error "el archivo ya está siendo usado por otro proceso" o "demasiados archivos abiertos".

Otro detalle — ojo con la codificación. Si no estás seguro de que el archivo es UTF-8, pon la codificación que toca. Para eso está el segundo parámetro del constructor de StreamReader.

Otra "trampa" práctica puede ser si el archivo se actualiza mientras el programa está funcionando (por ejemplo, un archivo de log). No siempre puedes ver las nuevas líneas al instante si el archivo lo usan otros procesos — entonces hay que volver a contar/leer el archivo o usar métodos especiales, pero eso lo veremos más adelante.

2
Tarea
C# SELF, nivel 36, lección 2
Bloqueada
Lectura de las primeras N líneas de un archivo
Lectura de las primeras N líneas de un archivo
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION