1. Introducción
Trabajar directamente con streams (StreamReader, StreamWriter, FileStream) es muy útil, sobre todo cuando necesitas controlar el proceso de lectura/escritura a bajo nivel: por ejemplo, escribir bloques "poco a poco" o procesar archivos grandes por partes.
Pero en la vida real muchas veces solo necesitas saber: "¿existe este archivo?", "copiar un archivo de un sitio a otro", "eliminar un archivo", "obtener la lista de todos los .txt en una carpeta", etc. Para esas tareas Microsoft creó dos herramientas universales: las clases estáticas File y Directory. Estáticas — significa que no hace falta crear una instancia, llamas directamente al método por el nombre de la clase.
Análogo de la vida real
Si los streams son tú con un lápiz que escribe letra por letra en una hoja, entonces File y Directory son tu mesa con cajones: puedes "abrir instantáneamente" un cajón (Directory), sacar un papel (File.ReadAllText), tirar el papel (File.Delete) o incluso sacar todo un cajón y mandarlo al otro extremo de la habitación (Directory.Move). Tareas simples — métodos simples.
2. La clase File: qué es y para qué sirve
La clase File tiene un conjunto muy cómodo de métodos estáticos para las operaciones más populares con archivos.
Métodos más usados
| Método | Descripción |
|---|---|
|
Comprueba si existe un archivo en la ruta |
|
Lee todo el archivo como texto |
|
Lee todas las líneas del archivo en un array |
|
Reescribe el archivo escribiendo el texto |
|
Agrega texto al final del archivo |
|
Copia un archivo |
|
Elimina un archivo |
|
Mueve o renombra un archivo |
|
Abre un stream para operaciones más complejas |
Ejemplo rápido: comprobamos el archivo y lo leemos
string filePath = "data.txt";
if (File.Exists(filePath))
{
string content = File.ReadAllText(filePath);
Console.WriteLine("Contenido del archivo:");
Console.WriteLine(content);
}
else
{
Console.WriteLine("¡Archivo no encontrado!");
}
¿Ves? ¡Nada de manejar streams manualmente para un caso simple!
3. La clase Directory: maneja carpetas sin dolor
Si File trata sobre archivos individuales, entonces Directory trata sobre carpetas (directorios).
Tareas principales
| Método | Descripción |
|---|---|
|
Comprueba si existe la carpeta |
|
Crea una carpeta (o la ruta con todas las carpetas intermedias) |
|
Elimina una carpeta (puede incluir subdirectorios) |
|
Obtiene la lista de archivos en la carpeta |
|
Obtiene la lista de subdirectorios |
|
Mueve o renombra una carpeta |
|
Obtener el directorio de trabajo actual de la aplicación |
Ejemplo: creamos una carpeta y guardamos un archivo allí
string dirPath = "Results";
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
Console.WriteLine("Carpeta 'Results' creada.");
}
string filePath = Path.Combine(dirPath, "summary.txt");
File.WriteAllText(filePath, "Datos finales: ...");
Console.WriteLine($"Archivo {filePath} escrito.");
4. Escenarios típicos de uso de File y Directory
Los métodos básicos pueden parecer aburridos si no los ves en acción. Veamos cómo usar estas clases para resolver tareas reales y, de paso, seguimos con nuestra aplicación hipotética (imagina que hacemos un sistema simple para gestionar una lista de tareas — todo-list — y guardamos el resultado en archivos).
Guardar datos en un archivo (reemplazando el archivo anterior)
// Guardamos la lista de tareas en un archivo
string[] todos = { "Buy bread", "Call doctor", "Do C# homework" };
string filePath = "todo.txt";
File.WriteAllLines(filePath, todos);
Console.WriteLine("Lista de tareas guardada.");
Cargar datos desde un archivo
// Cargamos tareas si el archivo existe
if (File.Exists(filePath))
{
string[] loadedTodos = File.ReadAllLines(filePath);
Console.WriteLine("Tu lista de tareas:");
foreach (var task in loadedTodos)
{
Console.WriteLine("- " + task);
}
}
else
{
Console.WriteLine("Aún no tienes una lista de tareas.");
}
Agregar una nueva tarea (sin sobrescribir el archivo)
string newTask = "Walk the dog";
File.AppendAllText(filePath, newTask + Environment.NewLine);
Console.WriteLine("¡Tarea agregada!");
Copiar y hacer backup de un archivo
string backupPath = "todo_backup.txt";
File.Copy(filePath, backupPath, overwrite: true);
Console.WriteLine("Copia de seguridad de la lista de tareas creada.");
Mover (o renombrar) un archivo
string archivePath = "todo_archive.txt";
File.Move(filePath, archivePath);
Console.WriteLine("Lista de tareas archivada (renombrada).");
Eliminar un archivo
if (File.Exists(archivePath))
{
File.Delete(archivePath);
Console.WriteLine("Archivo de archivo eliminado — ¡liberamos espacio!");
}
5. Trabajo con carpetas: ejemplos
Crear una jerarquía de directorios
string path = Path.Combine("Reports", "2024", "June");
Directory.CreateDirectory(path);
Console.WriteLine($"Carpeta {path} creada (incluyendo carpetas intermedias).");
Obtener la lista de archivos y carpetas
string dirPath = "Reports";
if (Directory.Exists(dirPath))
{
string[] files = Directory.GetFiles(dirPath);
Console.WriteLine("Archivos en la carpeta:");
foreach (var file in files)
{
Console.WriteLine(file);
}
string[] subDirs = Directory.GetDirectories(dirPath);
Console.WriteLine("Subdirectorios:");
foreach (var dir in subDirs)
{
Console.WriteLine(dir);
}
}
Filtrar archivos por máscara (solo txt)
string[] txtFiles = Directory.GetFiles(dirPath, "*.txt");
Console.WriteLine("Solo archivos .txt:");
foreach (var file in txtFiles)
{
Console.WriteLine(file);
}
Recorrido recursivo (archivos en todos los subdirectorios)
string[] allFiles = Directory.GetFiles(dirPath, "*.*", SearchOption.AllDirectories);
Console.WriteLine("Archivos en todas las carpetas anidadas:");
foreach (var file in allFiles)
{
Console.WriteLine(file);
}
Mover y eliminar directorios
string from = "OldReports";
string to = "Archive/OldReports";
if (Directory.Exists(from))
{
Directory.Move(from, to);
Console.WriteLine($"Carpeta {from} movida a {to}");
}
if (Directory.Exists(to))
{
Directory.Delete(to, recursive: true); // true: eliminar todo dentro
Console.WriteLine($"Carpeta {to} eliminada (con todo su contenido).");
}
6. Matices útiles
Integración con rutas: la clase Path
Al trabajar con archivos y carpetas a menudo necesitas componer rutas completas, unir nombres de directorios y archivos, obtener extensiones, comprobar caracteres válidos. Para eso se usa la clase auxiliar Path.
Ejemplos
string folder = "Results";
string filename = "week1.txt";
string fullPath = Path.Combine(folder, filename); // ¡unión segura!
Console.WriteLine(fullPath); // "Results/week1.txt" (o "\" en Windows)
- Obtener la extensión del archivo: Path.GetExtension(fullPath)
- Obtener el nombre de archivo sin la ruta: Path.GetFileName(fullPath)
Usa Path.Combine en lugar de concatenar strings — es más seguro para aplicaciones cross-platform.
Métodos "todo de una vez" vs variante basada en streams
Muchos métodos de File y Directory (por ejemplo, File.ReadAllText, File.WriteAllText, Directory.GetFiles) hacen todo "de una vez": leen/escriben/recuperan la lista en una sola operación. Esto es MUY conveniente, pero no es adecuado para archivos o directorios muy grandes, donde la memoria puede agotarse. Si trabajas con gigabytes — cambia a clases basadas en streams (StreamReader, StreamWriter, FileStream, etc.) o procesa archivos por partes.
Cuándo usar File/Directory y cuándo usar clases de streams
| Situación | Qué usar |
|---|---|
| Necesitas comprobar si existe archivo/carpeta | |
| Leer/escribir un archivo pequeño completo | |
| Agregar texto al final del archivo | |
| Obtener la lista de archivos en un directorio | |
| Copiar, eliminar, mover un archivo | |
| Copiar/eliminar una carpeta entera | Directory.Delete/Move/Copy (Copy — con una librería externa) |
| Procesar archivos MUY grandes por partes | Clases basadas en streams (StreamReader, FileStream) |
Valor práctico y uso real
- Carga/guardado rápido de configuraciones, settings, archivos JSON/XML.
- Sistemas de logging (escritura de logs en disco).
- Utilidades simples de backup y migración de datos.
- Escaneo de carpetas con multimedia, fotos, documentos.
- Escenarios de usuario: carga de plantillas, export/import, generación de reportes, etc.
Tareas prácticas en entrevistas también suelen requerir usar estas clases: "Implementa una función que calcule el tamaño total de todos los .txt en un directorio", "Haz una copia de seguridad de los archivos en otra carpeta", etc.
Chuleta visual: cuándo usar cada método
graph TD
A[¿Qué quieres hacer?]
A -->|Comprobar existencia| B[File.Exists o Directory.Exists]
A -->|Leer/escribir archivo completo| C[File.ReadAllText/WriteAllText]
A -->|Agregar datos a un archivo| D[File.AppendAllText]
A -->|Trabajo con carpetas| E[Directory.CreateDirectory, GetFiles, GetDirectories]
A -->|Copiar/eliminar/mover archivo| F[File.Copy/Delete/Move]
A -->|Copiar/eliminar carpeta entera| G[Directory.Delete/Move]
7. Particularidades y errores típicos
Comprobación de existencia y "race condition". Incluso si compruebas que un archivo/carpeta existe, entre esa comprobación y la operación real otro proceso puede cambiarlo. Por eso siempre usa try-catch aunque ya hayas comprobado la existencia.
Permisos de acceso. Si la aplicación no tiene permisos para leer/escribir/eliminar, los métodos lanzarán UnauthorizedAccessException.
Ruta demasiado larga. La longitud máxima de la ruta (normalmente 260 caracteres en Windows antiguos; en .NET 9 las restricciones son más flexibles, pero aun así ten cuidado).
Manejo de errores. Métodos como File.ReadAllText o Directory.GetFiles no perdonan errores: si el archivo/carpeta no existe — lanzan excepción. Envuelve en try-catch o comprueba la existencia previamente.
GO TO FULL VERSION