1. Clase File: simpleza y eficacia
La clase System.IO.File representa la idea de "una operación — un método". Te da un set de métodos de alto nivel que encapsulan la lógica complicada de interactuar con el sistema operativo, permitiéndote centrarte en tu tarea.
¿Qué puede hacer exactamente la clase File?
- Escribir texto o datos binarios arbitrarios en un archivo.
- Leer el contenido de un archivo entero o por líneas (para archivos de texto).
- Copiar, borrar y renombrar archivos existentes.
- Comprobar si existe un archivo en una ruta dada.
- Trabajar con atributos del archivo (por ejemplo, fecha de creación, tamaño – usando clases relacionadas).
¿Por qué es cómodo?
Todos los métodos de File son estáticos. O sea, no tienes que crear un objeto para usarlos, basta con llamar el método que necesitas, por ejemplo:
File.WriteAllText("data.txt", "¡Hola, archivo!");
Este estilo es muy parecido a trabajar con la clase Console: todo es simple y claro, no tienes que "crear" nada ni preocuparte por streams.
Si quieres tener a mano una herramienta universal y cómoda para trabajar con archivos, la clase System.IO.File es justo eso. Ofrece un montón de métodos para leer, escribir, copiar, borrar y otras operaciones básicas con archivos, como una navaja suiza para el sistema de archivos.
¿Cómo usar File?
Todos los métodos de la clase File son estáticos, o sea, no tienes que crear un objeto para usarlos — simplemente escribes File.Algo(). Es muy parecido a llamadas como Console.WriteLine(), solo que ahora para archivos.
string text = "¡Hola, mundo!";
string path = "hello.txt";
// Escribir texto en un archivo (si ya existe, lo sobrescribe)
File.WriteAllText(path, text);
// Leer todo el archivo en una sola cadena
string readText = File.ReadAllText(path);
Console.WriteLine("Contenido del archivo: " + readText);
Truco: Si escribes ReadAllText y WriteAllText diez veces seguidas, probablemente estás haciendo algo mal — estos métodos son buenos para escenarios simples y archivos pequeños.
Métodos más usados de la clase File
| Método | Descripción |
|---|---|
|
Comprueba si existe un archivo en la ruta indicada |
|
Borra un archivo |
|
Copia un archivo |
|
Mueve (o renombra) un archivo |
|
Lee todo el archivo como una sola cadena |
|
Escribe una cadena en un archivo (sobrescribe si ya existe) |
|
Lee todas las líneas del archivo en un array de cadenas |
|
Escribe un array de cadenas en un archivo (cada cadena es una línea) |
|
Lee todos los bytes del archivo en un array de bytes |
|
Escribe un array de bytes en un archivo |
2. Escribir y leer archivos de texto
Vamos a ver los métodos más usados de la clase File con ejemplos prácticos. Para usarlos siempre necesitas la directiva using System.IO; al principio de tu archivo de código.
using System;
using System.IO; // Obligatorio para trabajar con la clase File
using System.Linq; // Puede hacer falta para ReadLines
Leer un archivo completo
Esta es una de las tareas más comunes: guardar datos de texto en un archivo o cargarlos de vuelta.
Escribir una línea (o todo el texto) en un archivo: File.WriteAllText() Este método crea un archivo nuevo en la ruta indicada. Si ya existe un archivo con ese nombre, su contenido será completamente sobrescrito por el nuevo texto.
string myFilePath = "notes.txt";
string textContent = "Hoy es un gran día para aprender C#.\nNo olvides hacer los deberes.";
// Escribimos todo el texto en el archivo
File.WriteAllText(myFilePath, textContent);
Console.WriteLine($"El archivo '{myFilePath}' se ha creado/sobrescrito correctamente.");
Leer un archivo completo en una sola cadena: File.ReadAllText() Este método lee todo el contenido del archivo de texto de principio a fin y lo devuelve como una sola cadena grande.
string myFilePath = "notes.txt";
// Importante: ¡siempre comprueba si el archivo existe antes de leerlo para evitar errores!
if (File.Exists(myFilePath))
{
string content = File.ReadAllText(myFilePath);
Console.WriteLine($"Contenido del archivo '{myFilePath}':\n{content}");
}
else
{
Console.WriteLine($"Error: El archivo '{myFilePath}' no se ha encontrado para leer.");
}
Nota importante: Los métodos File.WriteAllText() y File.ReadAllText() van genial para archivos pequeños y medianos (por ejemplo, notas de texto, archivos de configuración, logs cortos). Pero si el archivo es muy grande (digamos, decenas o cientos de megas, o incluso gigas), cargar todo su contenido en una sola cadena en la memoria RAM puede consumir un montón de memoria e incluso provocar una OutOfMemoryException. Para esos casos hay formas más eficientes (de eso hablamos más abajo y en próximas lecciones).
3. Leer un archivo línea por línea
Cuando trabajas con archivos de texto grandes, como informes CSV enormes, archivos de logs largos o bases de datos de texto, leerlos enteros en memoria (o sea, cargar todo el archivo de golpe desde el disco a la RAM del ordenador) se vuelve ineficiente o incluso imposible. Aquí es donde File.ReadLines() te salva.
File.ReadLines(path) — este método no carga todo el archivo de golpe. En vez de eso, devuelve una colección especial (IEnumerable<string>) que te permite leer el archivo línea a línea según lo necesites. Esto se llama "lectura perezosa" o "lectura en streaming".
string logFilePath = "application.log";
string text = """
INFO: La aplicación se ha iniciado.
WARN: Se ha detectado un problema en el módulo X.
ERROR: Error crítico de red.
INFO: La aplicación se ha detenido.
""";
// Supongamos que tenemos un archivo de log con muchas líneas.
File.WriteAllText(logFilePath, text);
// Cada iteración del bucle lee y procesa SOLO UNA línea
foreach (string line in File.ReadLines(logFilePath))
Console.WriteLine($"- {line}");
Ventaja: El archivo se lee y procesa por partes, lo que reduce mucho el consumo de memoria al trabajar con archivos grandes.
Diferencia entre File.ReadLines() y File.ReadAllLines():
- File.ReadAllLines(path): Carga todas las líneas del archivo de golpe en la memoria y las devuelve como un array string[]. Después de llamar a este método, todo el archivo ya está en memoria. Es útil si necesitas acceso completo a todas las líneas a la vez (por ejemplo, para ordenar o buscar).
- File.ReadLines(path): Devuelve un IEnumerable<string> que te permite recorrer las líneas del archivo una a una. El archivo se lee solo cuando pides la siguiente línea (por ejemplo, en un bucle foreach). Es más eficiente para archivos muy grandes, cuando no puedes o no quieres cargar todo en memoria.
4. Escribir un array de líneas
A veces tienes una lista de cadenas (por ejemplo, de alguna colección), y quieres escribir cada cadena como una línea separada en un archivo.
File.WriteAllLines(path, contents)
Este método recibe un array de cadenas (o cualquier colección de cadenas) y escribe cada cadena como una línea separada en el archivo. Igual que WriteAllText(), sobrescribe el archivo si ya existe.
string membersFilePath = "participants.txt";
string[] names = { "Iván Petrov", "María Sidorova", "Sergio Kozlov", "Ana Kuznetsova" };
// Cada línea del array se escribirá como una línea separada en el archivo
File.WriteAllLines(membersFilePath, names);
// Comprobamos el contenido
Console.WriteLine($"Contenido de '{membersFilePath}':");
foreach (string line in File.ReadLines(membersFilePath))
Console.WriteLine($"- {line}");
5. Trabajando con archivos binarios
La clase File no se limita solo a datos de texto. También te da métodos cómodos para leer y escribir datos binarios, o sea, bytes en bruto. Esto es útil, por ejemplo, para guardar configuraciones en un formato específico, trabajar con imágenes, audio o cualquier dato que no sea texto normal.
Escribir un array de bytes: File.WriteAllBytes() Crea o sobrescribe un archivo, escribiendo en él todo el array de bytes que le pases.
string binaryDataPath = "settings.bin";
// Ejemplo de datos binarios: imagen, vídeo, cualquier dato
byte[] settingsData = { 0x01, 0x0A, 0x2C, 0xFF, 0x00, 0x3F }; // Algunas "configuraciones" en bruto
File.WriteAllBytes(binaryDataPath, settingsData);
Console.WriteLine($"Datos binarios escritos en el archivo '{binaryDataPath}'.");
Importante: si intentas abrir 'settings.bin' en el Bloc de notas, verás símbolos raros ("caracteres basura"), porque esos bytes no están pensados para interpretarse como texto.
Leer un array de bytes: File.ReadAllBytes() Lee todo el contenido de un archivo binario en un array de bytes.
if (File.Exists(binaryDataPath))
{
byte[] readSettings = File.ReadAllBytes(binaryDataPath);
Console.WriteLine($"Leídos {readSettings.Length} bytes del archivo '{binaryDataPath}'.");
Console.Write("Bytes leídos (en hexadecimal): ");
foreach (byte b in readSettings)
Console.Write($"{b:X2} "); // :X2 formatea el byte como un número hexadecimal de dos dígitos
Console.WriteLine();
}
else
{
Console.WriteLine($"Error: El archivo binario '{binaryDataPath}' no se ha encontrado.");
}
Estos métodos son muy cómodos para guardar pequeñas porciones de datos binarios, por ejemplo, para cachear imágenes pequeñas o objetos serializados.
6. Gestionar archivos en disco
La clase File también te da métodos para gestionar archivos en disco.
Comprobar si existe un archivo: File.Exists(path) Devuelve true si el archivo existe en la ruta indicada, y false si no. Es muy recomendable usar este método antes de intentar leer, borrar u otras operaciones que pueden dar error si el archivo no existe.
string myFileToCheck = "report.txt";
// Primero lo creamos para el ejemplo
File.WriteAllText(myFileToCheck, "Informe de prueba.");
if (File.Exists(myFileToCheck))
{
Console.WriteLine($"El archivo '{myFileToCheck}' ha sido encontrado.");
// Ahora puedes leer, borrar, etc. con seguridad
}
else
{
Console.WriteLine($"El archivo '{myFileToCheck}' no ha sido encontrado.");
}
Borrar un archivo: File.Delete(path) borra el archivo del disco para siempre. ¡Ojo, esta acción no se puede deshacer!
string fileToDelete = "temp_file.txt";
// Creamos el archivo para el ejemplo
File.WriteAllText(fileToDelete, "Este archivo será borrado.");
if (File.Exists(fileToDelete))
{
File.Delete(fileToDelete);
Console.WriteLine($"El archivo '{fileToDelete}' se ha borrado correctamente.");
}
else
{
Console.WriteLine($"El archivo '{fileToDelete}' ya no existe o fue borrado antes.");
}
7. Excepciones al trabajar con archivos
Trabajar con archivos siempre implica interactuar con el sistema operativo y recursos externos, lo que lo hace potencialmente vulnerable a errores.
¡Maneja las excepciones (errores)! Al trabajar con archivos pueden pasar un montón de cosas que tu programa debe saber manejar bien, y no simplemente "petar". Situaciones típicas:
- FileNotFoundException: El archivo al que intentas acceder no existe en la ruta indicada.
- DirectoryNotFoundException: La carpeta donde intentas crear o buscar el archivo no existe.
- UnauthorizedAccessException: Tu programa no tiene permisos para leer, escribir o borrar el archivo/carpeta (por ejemplo, si es un archivo del sistema o está en una zona protegida).
- IOException: Error general de entrada/salida, suele pasar cuando el archivo ya está abierto por otro programa y bloqueado, o no hay espacio en disco.
Usa siempre la estructura try-catch para trabajar seguro con archivos. Así puedes "atrapar" el error y hacer algo al respecto (por ejemplo, mostrar un mensaje al usuario, escribir en un log).
string sensitiveFilePath = "secret_data.txt";
try
{
// Intento de leer un archivo que puede que no exista o no tengas acceso
string secretContent = File.ReadAllText(sensitiveFilePath);
Console.WriteLine($"Contenido secreto leído: {secretContent}");
}
catch (FileNotFoundException) // Error concreto: archivo no encontrado
{
Console.WriteLine($"Error: El archivo '{sensitiveFilePath}' no se ha encontrado. Asegúrate de que la ruta es correcta.");
}
catch (IOException ex) // Error general de entrada/salida (por ejemplo, archivo bloqueado)
{
Console.WriteLine($"Error de entrada/salida al trabajar con el archivo '{sensitiveFilePath}': {ex.Message}");
}
catch (Exception ex) // Cualquier otro error inesperado
{
Console.WriteLine($"Ha ocurrido un error inesperado: {ex.Message}");
}
8. ¿Cuándo System.IO.File no es la mejor opción?
Aunque la clase File es súper versátil, hay escenarios donde no es óptima o ni siquiera posible usarla:
Archivos enormes (decenas+ de gigas): Los métodos ReadAllText()/ReadAllBytes() cargan todo el archivo en memoria. Para archivos muy grandes esto te dará una OutOfMemoryException. En esos casos File.ReadLines() (para texto) o el enfoque directo con streams (FileStream) es necesario para leer/escribir por partes. (Sobre streams hablaremos en la próxima lección).
Control fino sobre el acceso al archivo: Si necesitas un control muy específico sobre cómo se abre el archivo (por ejemplo, acceso exclusivo para que nadie más pueda leer o escribir, o al revés, acceso simultáneo de varios procesos), File no te da ese nivel de detalle. Para eso necesitas clases de streams de bajo nivel.
Operaciones asíncronas: Para apps de alto rendimiento que necesitan hacer operaciones de archivos sin bloquear el hilo principal (por ejemplo, en servidores web), necesitas métodos asíncronos (como ReadAllTextAsync()), que también se basan en streams.
Lectura/escritura parcial: Si necesitas leer solo una parte del archivo desde un offset concreto o escribir datos en medio de un archivo existente, los métodos de File no te sirven. Para eso necesitas acceso directo al stream del archivo.
9. Resumen
¿Por qué System.IO.File es tan popular?
- Simpleza y concisión: Sus métodos estáticos te permiten hacer operaciones complejas en una o dos líneas de código. Esto simplifica mucho el desarrollo y hace el código más legible.
- Gestión automática de recursos: File se encarga de abrir y cerrar archivos en cada operación, así no tienes que gestionar recursos manualmente (lo que suele causar errores).
- Versatilidad para tareas diarias: Para la mayoría de operaciones típicas con archivos de texto y binarios pequeños y medianos, las posibilidades de File son más que suficientes.
- Muy usado: En la mayoría de tareas prácticas y entrevistas se espera que sepas usar bien los métodos de la clase File.
- Complejidad oculta: Todos los métodos están hechos para encapsular la lógica complicada de interactuar con el sistema operativo, dándote una interfaz limpia y clara.
Preguntas frecuentes y aclaraciones
¿Cuál es el tamaño máximo de archivo permitido para File.ReadAllText()?
Para archivos de hasta varias decenas de megas (< 100 MB) normalmente no hay problema. Si el archivo es más grande (cientos de MB, gigas), usar File.ReadAllText() puede agotar la memoria RAM (excepción OutOfMemoryException). En esos casos deberías usar File.ReadLines() para leer línea a línea o herramientas más avanzadas para procesamiento en streaming, de las que aprenderás más adelante.
¿Se puede crear/escribir un archivo en una carpeta que no existe?
No. Los métodos File.WriteAllText(), File.WriteAllBytes() y otros no crean las carpetas padre automáticamente. Si pones la ruta C:\MyAppData\Logs\current.log, pero las carpetas MyAppData o Logs no existen, tendrás una DirectoryNotFoundException. Primero tienes que asegurarte de que todas las carpetas necesarias existen, usando métodos de la clase System.IO.Directory (por ejemplo, Directory.CreateDirectory("myfolder")).
¿Cómo saber la fecha de creación, modificación o el tamaño de un archivo?
Para obtener más información sobre un archivo, como fecha de creación, fecha de última modificación, tamaño, atributos (oculto, solo lectura, etc.), usa la clase System.IO.FileInfo. Te da un montón de propiedades útiles.
GO TO FULL VERSION