Hasta ahora, todo el estado de BiblioTech —el catálogo, los socios, el historial de préstamos— vive únicamente en la memoria del programa: en cuanto el proceso termina, todo desaparece con él. Esta lección abre el Módulo 5 (Trabajando con Datos) atacando exactamente ese problema por el camino más directo: leer y escribir ficheros en disco con el namespace System.IO. Aprenderás a comprobar si un fichero existe, a leerlo y escribirlo de una vez o línea a línea, a liberar correctamente los recursos que abres, y a manejar los errores propios de la E/S (entrada/salida). Al final de la lección, Biblioteca sabrá guardar y recuperar su catálogo completo en un fichero de texto plano, la primera forma —muy básica— de persistencia real de todo el curso.

1. El namespace System.IO y los dos niveles de trabajo con ficheros
2. Comprobar la existencia de un fichero: File.Exists
3. Todo de una vez: File.ReadAllText/File.WriteAllText y File.ReadAllLines/File.WriteAllLines
4. Ficheros grandes: StreamReader y StreamWriter
5. using e IDisposable: liberar recursos correctamente
6. Manejo de excepciones de E/S: IOException y FileNotFoundException
7. Persistiendo el catálogo de BiblioTech en texto plano

Todo lo relacionado con ficheros y directorios en .NET vive en el namespace System.IO. Dentro de él conviven dos niveles de trabajo, pensados para necesidades distintas:

Ambos niveles acaban usando el mismo mecanismo por debajo (un Stream que representa el flujo de bytes hacia o desde el disco), pero File te ahorra la gestión manual del flujo cuando el tamaño del fichero no es un problema. Esta lección presenta primero File, por ser el punto de entrada más sencillo, y después StreamReader/StreamWriter para cuando ese enfoque no basta.

Antes de leer un fichero, conviene comprobar que existe; antes de escribirlo, no siempre hace falta (File.WriteAllText lo crea si no existe), pero sí es una buena práctica antes de cualquier lectura:

File.Exists(ruta) devuelve true/false sin lanzar ninguna excepción, incluso si la ruta tiene un formato inválido o el directorio no existe (en esos casos simplemente devuelve false). Es la forma segura de anticiparse a un fichero ausente, en vez de intentar leerlo directamente y capturar la excepción que eso provocaría.

La clase estática File ofrece cuatro métodos de uso inmediato para trabajar con el contenido completo de un fichero:

Ambos métodos de escritura sobrescriben el fichero si ya existía (no añaden contenido al final); si necesitas añadir sin borrar lo anterior, existen las variantes File.AppendAllText y File.AppendAllLines, con la misma forma de uso. Estos cuatro métodos son la opción por defecto siempre que el fichero sea de un tamaño razonable: internamente abren el fichero, leen o escriben todo su contenido, y lo cierran automáticamente por ti, sin que tengas que gestionar nada más.

Cuando un fichero es demasiado grande para cargarlo entero en memoria de golpe (piensa en un .csv con millones de filas), o cuando quieres empezar a procesar sus líneas antes de que termine de leerse por completo, File.ReadAllText/File.ReadAllLines dejan de ser adecuados: cargan todo el fichero en memoria antes de devolver el control. StreamReader y StreamWriter resuelven esto trabajando línea a línea, sin necesidad de tener el fichero completo en memoria en ningún momento:

ReadLine() devuelve null cuando llega al final del fichero, lo que permite usarlo directamente como condición de un while: el bucle se repite mientras haya líneas, y termina solo cuando ReadLine() devuelve null. Este patrón (while ((linea = lector.ReadLine()) != null)) es tan habitual en C# que conviene memorizarlo tal cual.

El ejemplo anterior tiene, a propósito, un problema: si ocurriera una excepción entre la apertura y el Close(), el fichero quedaría abierto para siempre (un fugado de recursos, resource leak). El siguiente apartado resuelve exactamente eso.

StreamReader y StreamWriter (igual que SqliteConnection, que verás en la lección de Conectividad con Bases de Datos) representan un recurso externo al programa —un fichero abierto por el sistema operativo— que debe liberarse explícitamente cuando se termina de usar. Todos implementan la interfaz IDisposable (recuerda IDisposable de la lección de Constructores y Destructores, Módulo 3), cuyo método Dispose() libera ese recurso.

Llamar a Dispose() (o a su equivalente Close()) manualmente, como en el apartado anterior, funciona, pero obliga a acordarse de hacerlo en todos los caminos de salida del método, incluidos los que pasan por una excepción. La sentencia using automatiza esto por completo:

Desde C# 8 existe además la using declaration, sin llaves propias, que libera el recurso al final del bloque que la contiene (el método, o el bloque { } en el que se declaró):

Regla práctica para el resto del curso: cualquier objeto que implemente IDisposable (ficheros, conexiones a bases de datos, HttpClient...) se declara con using, sin excepciones, salvo casos muy concretos que quedan fuera del alcance de este curso.

Cualquier operación de E/S puede fallar por motivos ajenos al programa: el fichero no existe, el disco está lleno, otro proceso lo tiene bloqueado, no hay permisos suficientes... Todas estas situaciones se manifiestan mediante excepciones, que se manejan con try/catch, exactamente como en la lección de Manejo de Excepciones (Módulo 2):

FileNotFoundException, DirectoryNotFoundException y UnauthorizedAccessException heredan, de hecho, de IOException, así que un único catch (IOException ex) captura cualquiera de ellas si no necesitas distinguirlas; si sí lo necesitas, coloca los catch más específicos primero, como aprendiste en la lección de excepciones:

En la práctica, comprobar File.Exists de antemano evita la mayoría de los FileNotFoundException; el resto de excepciones de IOException sí conviene capturarlas siempre que el programa dependa de que la operación tenga éxito.

Con todo lo anterior, Biblioteca gana dos métodos nuevos para guardar y recuperar su catálogo (Catalogo, de la lección de Colecciones) en un fichero de texto plano: una línea por material, con los campos separados por ;. Como el catálogo mezcla Libro y Revista (recuerda la lección de Herencia), cada línea empieza con un campo adicional que identifica el tipo:

Algunos detalles de este parseo manual merecen explicarse:

• linea.Split(';') (recordando Arrays y Cadenas de Texto, Módulo 1) trocea cada línea en un string[] usando ; como separador; el orden de los campos debe coincidir exactamente entre GuardarCatalogoTexto (al escribir) y CargarCatalogoTexto (al leer).
• El switch de expresión (Pattern Matching, Módulo 4) reconstruye el tipo concreto (Libro o Revista) a partir del primer campo, reutilizando sus constructores tal cual se definieron en la lección de Herencia.
• CargarCatalogoTexto reutiliza AgregarMaterial, ya existente en Biblioteca, en vez de llamar directamente a Catalogo.Add(...): la lógica de alta queda en un único sitio.
• Este formato es deliberadamente frágil: si un título contuviera un ;, el Split produciría más campos de los esperados y el parseo fallaría. Es exactamente la limitación que motiva la siguiente lección, Serialización, con un formato (JSON) que no tiene este problema.

• Olvidar using en un StreamReader/StreamWriter: sin él, el fichero puede quedar bloqueado para otros procesos, o los datos escritos pueden no llegar a guardarse en disco si el proceso termina antes de llamar a Close()/Dispose() explícitamente. Usa siempre using, sin excepción, para cualquier tipo que implemente IDisposable.
• Leer un fichero sin comprobar antes File.Exists: intentar File.ReadAllText sobre un fichero inexistente lanza FileNotFoundException; compruébalo antes, o captura la excepción si prefieres el enfoque "intenta y captura" en vez de "comprueba antes".
• Confundir File.WriteAllText/WriteAllLines con "añadir al final": ambos sobrescriben el fichero completo si ya existía; usa File.AppendAllText/File.AppendAllLines si la intención es añadir contenido sin perder el anterior.
• Un separador que puede aparecer dentro de los propios datos: el ; de este formato de texto plano no está pensado para títulos que ya contengan un ;; en un caso real habría que escapar el separador o elegir un formato más robusto (el problema que resuelve la lección siguiente).
• Consejo: para ficheros pequeños o medianos (la inmensa mayoría de los casos en una aplicación típica), File.ReadAllText/WriteAllText/ReadAllLines/WriteAllLines son más simples y menos propensos a errores que gestionar un StreamReader/StreamWriter a mano; resérvalos para ficheros realmente grandes o para procesar línea a línea sin cargarlo entero.

1. Escribe un fragmento de código que use File.WriteAllLines para guardar tres títulos de libro en un fichero titulos.txt, y después File.ReadAllLines para leerlos de vuelta y mostrarlos por consola, uno por línea.

2. Escribe un método void MostrarFicheroSiExiste(string ruta) que compruebe con File.Exists si el fichero existe: si existe, léelo con File.ReadAllText y muéstralo por consola dentro de un try/catch que capture IOException; si no existe, muestra un mensaje indicándolo, sin intentar leerlo.

3. Construye GuardarCatalogoTexto y CargarCatalogoTexto en Biblioteca tal como se han presentado en esta lección. Crea una Biblioteca, añade dos libros y una revista, guarda el catálogo en catalogo.txt, crea una segunda instancia de Biblioteca vacía, carga el fichero en ella con CargarCatalogoTexto, y comprueba que Catalogo.Count coincide entre ambas instancias.

string[] titulos = { "Rayuela", "Ficciones", "El Aleph" };
File.WriteAllLines("titulos.txt", titulos);

string[] titulosLeidos = File.ReadAllLines("titulos.txt");
foreach (string titulo in titulosLeidos)
{
    Console.WriteLine(titulo);
}

void MostrarFicheroSiExiste(string ruta)
{
    if (!File.Exists(ruta))
    {
        Console.WriteLine($"El fichero '{ruta}' no existe.");
        return;
    }

    try
    {
        string contenido = File.ReadAllText(ruta);
        Console.WriteLine(contenido);
    }
    catch (IOException ex)
    {
        Console.WriteLine($"Error de E/S al leer el fichero: {ex.Message}");
    }
}

Biblioteca origen = new Biblioteca();
origen.AgregarMaterial(new Libro("Rayuela", "Julio Cortazar", "978-84-376-0495-4"));
origen.AgregarMaterial(new Libro("Ficciones", "Jorge Luis Borges", "978-84-376-0496-1"));
origen.AgregarMaterial(new Revista("National Geographic", "Varios autores", 302));

origen.GuardarCatalogoTexto("catalogo.txt");

Biblioteca destino = new Biblioteca();
destino.CargarCatalogoTexto("catalogo.txt");

Console.WriteLine(origen.Catalogo.Count);  // 3
Console.WriteLine(destino.Catalogo.Count); // 3

En esta lección has aprendido a trabajar con ficheros usando System.IO: comprobar su existencia con File.Exists, leer y escribir de golpe con File.ReadAllText/WriteAllText y ReadAllLines/WriteAllLines, procesar ficheros grandes línea a línea con StreamReader/StreamWriter, liberar recursos correctamente con using, y manejar las excepciones propias de la E/S. Biblioteca ya puede guardar y recuperar su catálogo completo entre ejecuciones, con GuardarCatalogoTexto y CargarCatalogoTexto.

El formato de texto plano con ; como separador, sin embargo, es frágil: no soporta bien títulos con caracteres especiales, obliga a un parseo manual propenso a errores, y no escala bien a estructuras de datos más complejas (como préstamos, que enlazan un libro con un socio). La siguiente lección, Serialización, sustituye este parseo manual por System.Text.Json, un formato estándar que resuelve estos problemas de raíz y que reutilizará, precisamente, los ficheros que ya sabes leer y escribir gracias a esta lección.