CodeGym /Cursos /C# SELF /Clases estáticas File y Directory

Clases estáticas File y Directory

C# SELF
Nivel 39, Lección 0
Disponible

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
File.Exists(path)
Comprueba si existe un archivo en la ruta
File.ReadAllText(path)
Lee todo el archivo como texto
File.ReadAllLines(path)
Lee todas las líneas del archivo en un array
File.WriteAllText(path, text)
Reescribe el archivo escribiendo el texto
File.AppendAllText(path, text)
Agrega texto al final del archivo
File.Copy(source, destination)
Copia un archivo
File.Delete(path)
Elimina un archivo
File.Move(source, destination)
Mueve o renombra un archivo
File.Open/Read/Write/Create
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
Directory.Exists(path)
Comprueba si existe la carpeta
Directory.CreateDirectory(path)
Crea una carpeta (o la ruta con todas las carpetas intermedias)
Directory.Delete(path)
Elimina una carpeta (puede incluir subdirectorios)
Directory.GetFiles(path)
Obtiene la lista de archivos en la carpeta
Directory.GetDirectories(path)
Obtiene la lista de subdirectorios
Directory.Move(source, destination)
Mueve o renombra una carpeta
Directory.GetCurrentDirectory()
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
File.Exists, Directory.Exists
Leer/escribir un archivo pequeño completo
File.ReadAllText, WriteAllText
Agregar texto al final del archivo
File.AppendAllText
Obtener la lista de archivos en un directorio
Directory.GetFiles
Copiar, eliminar, mover un archivo
File.Copy/Delete/Move
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.

2
Tarea
C# SELF, nivel 39, lección 0
Bloqueada
Creación y eliminación de una carpeta
Creación y eliminación de una carpeta
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION