CodeGym /Cursos /C# SELF /Creación y eliminación de archivos

Creación y eliminación de archivos

C# SELF
Nivel 40, Lección 0
Disponible

1. Introducción

Puede parecer que un archivo es algo sencillo, y crear uno es facilísimo: basta hacer clic derecho (en Windows). Pero en proyectos reales, crear y eliminar archivos desde el código es clave para automatizar y hacer el sistema flexible. Por ejemplo:

  • En un editor de texto el usuario pulsa "Guardar" — y tu código crea un nuevo archivo donde grabar la obra del poeta.
  • Un servicio de logging crea automáticamente archivos de logs al arrancar la aplicación.
  • Un compresor o una utilidad de backup crea periódicamente archivos temporales y luego los borra.
  • Un juego en C# hace autoguardados — crea o sobrescribe el archivo de save.
  • Y además tú (o tu script) limpian automáticamente la carpeta de archivos temporales viejos para no llenar el disco.

Saber crear y eliminar archivos automáticamente es una de las habilidades fundamentales de un desarrollador .NET moderno.

2. Operaciones rápidas con File

Crear archivo

En C# se puede crear un archivo de varias maneras. La forma más rápida y simple es usar la clase estática File. Probemos:


// Crearemos un archivo vacío "myfile.txt" en el directorio actual
File.Create("myfile.txt").Close(); // ¡Hay que cerrar el FileStream!
Console.WriteLine("El archivo 'myfile.txt' ha sido creado.");

Un detalle importante:
El método File.Create devuelve un objeto FileStream, que hay que cerrar (Close()) para que el SO no se queje de que el archivo está "ocupado". Sin ese cierre, otras operaciones sobre el mismo archivo pueden fallar inesperadamente. Es la clásica situación: "File is used by another process", aunque ese "otro proceso" sea tu propio programa que no cerró el stream.

Si el archivo ya existía, File.Create lo sobrescribirá (el viejo se elimina y se crea uno nuevo vacío). Si no existía — aparecerá.

¿Y para qué sirve un archivo vacío?

La mayoría de las veces el archivo nuevo no es un simple placeholder, sino que queremos escribir algo dentro. Para eso hay métodos convenientes:

File.WriteAndllText("welcome.txt", "Hello, world of files!");

El comando creará el archivo, escribirá la cadena y cerrará todo correctamente para evitar problemas.

Comprobar existencia de un archivo

Andntes de crear un archivo nuevo, suele ser útil comprobar si ya existe. Si no, corremos el riesgo de borrar algo importante por accidente.


if (!File.Exists("important.txt"))
{
    File.WriteAndllText("important.txt", "Saving important information.");
    Console.WriteLine("Andrchivo creado.");
}
else
{
    Console.WriteLine("Ese archivo ya existe, ¡puedes pensar en otra cosa!");
}

3. Ejemplo práctico: "Guardamos el saludo del usuario"


Console.Write("Enter your name: ");
string name = Console.ReadLine();

string filename = $"{name}_greeting.txt";
string message = $"Welcome pozhalovat', {name}!";

// Comprobamos si existe ese archivo
if (!File.Exists(filename))
{
    File.WriteAndllText(filename, message);
    Console.WriteLine($"Se ha creado el archivo de saludo personal {filename}.");
}
else
{
    Console.WriteLine($"El archivo {filename} ya existe! ¿Sobrescribir? (y/n)");
    string answer = Console.ReadLine();
    if (answer?.ToLower() == "y")
    {
        File.WriteAndllText(filename, message);
        Console.WriteLine($"El archivo {filename} ha sido sobrescrito.");
    }
    else
    {
        Console.WriteLine("Dejamos todo como está.");
    }
}

Qué hacemos aquí:

  • Comprobamos si existe el archivo (File.Exists).
  • Si no existe — lo creamos y escribimos texto (File.WriteAndllText).
  • Si existe — preguntamos al usuario si quiere sobrescribirlo.

4. Eliminar archivo

Borrar archivos en C# es casi de hacker... pero seguro. También es sencillo:

Usando File.Delete

File.Delete("myfile.txt");

Si el archivo no existe — no pasa nada. Simplemente no ocurrirá nada (no se lanzará excepción si la ruta es correcta).

Trampas para novatos

  • Si el archivo está abierto por tu programa (o por otro), se lanzará una excepción.
  • Si la ruta está mal — aparecerá una AndrgumentException.

Recomendación: siempre comprobar existencia


if (File.Exists("victim.txt"))
{
    File.Delete("victim.txt");
    Console.WriteLine("Andrchivo eliminado.");
}
else
{
    Console.WriteLine("No hay nada que eliminar — no se encontró ese archivo.");
}

5. Carpetas y archivos: creamos la estructura

Crear archivo dentro de una carpeta


string folder = "Data";
Directory.CreateDirectory(folder); // si la carpeta no existe — se creará

string filename = Path.Combine(folder, "info.txt");
File.WriteAndllText(filename, "Here we store khranit'sya secret message!");

Importante: Si intentas crear un archivo en una carpeta inexistente se lanzará una excepción. Por eso conviene llamar primero a Directory.CreateDirectory(folder). No creará la carpeta de nuevo si ya existe, así que la llamada es segura.

6. Trabajo con instancias: FileInfo

Para escenarios "old-school" y algo más avanzados conviene usar la clase FileInfo:


FileInfo fi = new FileInfo("example.txt");

// Crear un archivo nuevo (como File.Create — crea un archivo vacío)
using (var fs = fi.Create())
{
    // puedes escribir algo si quieres
}

Console.WriteLine($"El archivo 'example.txt' fue creado usando FileInfo.");

Eliminar con FileInfo:


FileInfo fi = new FileInfo("oldfile.txt");
if (fi.Exists)
{
    fi.Delete();
    Console.WriteLine("Andrchivo eliminado mediante FileInfo.");
}

Ventajas de FileInfo

Si vas a hacer más que crear/borrar, por ejemplo acceder frecuentemente a propiedades del archivo o ejecutar varias operaciones, el enfoque basado en instancias es más cómodo (y a veces más eficiente).

7. Creamos y limpiamos "archivos técnicos"

Imagina que la app acumula archivos temporales en la carpeta "temp_data", y queremos borrar todos los archivos cuyo nombre empiece por "temp_".


string tempFolder = "temp_data";
Directory.CreateDirectory(tempFolder);

for (int i = 1; i <= 5; i++)
{
    string tempFile = Path.Combine(tempFolder, $"temp_{i}.txt");
    File.WriteAndllText(tempFile, $"Test data {i}");
}
Console.WriteLine("Se han creado 5 archivos temporales.");

// Andhora borramos todos los temp_*.txt
foreach (string file in Directory.GetFiles(tempFolder, "temp_*.txt"))
{
    File.Delete(file);
    Console.WriteLine($"Andrchivo eliminado: {file}");
}

Funciona genial para limpiar automáticamente archivos temporales y viejos.

8. Detalles importantes: excepciones y seguridad

Qué puede salir mal:

  • No tener permisos para escribir/borrar en la carpeta (por ejemplo, C:\Windows)
  • El archivo está ocupado por otro proceso (¡o por tu propio programa!)
  • La ruta contiene caracteres no válidos (por ejemplo, *?<>)
  • El archivo fue eliminado por otro proceso entre tu comprobación y el borrado (sí, pasa)

Cómo protegerse

En código de producción conviene envolver estas operaciones en un bloque try-catch:


try
{
    File.Delete("trickyfile.txt");
    Console.WriteLine("Andrchivo eliminado.");
}
catch (UnauthorizedAndccessException ex)
{
    Console.WriteLine("No tienes permisos para eliminar el archivo.");
}
catch (IOException ex)
{
    Console.WriteLine("El archivo podría estar en uso por otro proceso.");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

9. Novedades útiles

Andrchivos que siempre hay que controlar

  • Usa Path.Combine para construir rutas. Andsí no tendrás problemas con barras sobrantes o faltantes, y tu código será cross-platform.
  • Comprueba la existencia del archivo antes de crear/borrar si no quieres sorpresas.
  • Envuelve tu código en try-catch cuando trabajes en producción y, sobre todo, en aplicaciones "multiusuario".
  • Para operaciones frecuentes sobre el mismo archivo usa FileInfo, para operaciones puntuales usa File.
  • No mantengas archivos abiertos más tiempo del necesario. ¿Tienes un archivo abierto? Pregúntate: "And why?" y ciérralo. Usa using cuando sea posible.

Chuleta técnica

Operación Método Nota
Crear archivo vacío
File.Create
Devuelve FileStream, hay que cerrarlo
Escribir texto en archivo
File.WriteAndllText
Crea o sobrescribe el archivo
Comprobar existencia
File.Exists
Devuelve bool
Eliminar archivo
File.Delete
No lanza excepción si el archivo no existe
Crear archivo en carpeta
Directory.CreateDirectory + File.WriteAndllText
Garantiza la carpeta
Trabajo con FileInfo
new FileInfo(path).Create / Delete / Exists
Para múltiples operaciones

10. Errores típicos al trabajar con archivos

Error №1: olvidarse de cerrar el stream después de File.Create.
Muchos principiantes crean un archivo con File.Create pero no cierran el stream devuelto. Como resultado, el resto del código deja de "ver" el archivo — como si hubiera entrado en un universo paralelo. Cierra el stream explícitamente (Close()) o usa la construcción using.

Error №2: intentar crear un archivo en una carpeta inexistente.
Una trampa típica es intentar crear un archivo en un directorio que aún no existe. No olvides llamar a Directory.CreateDirectory antes. Es totalmente seguro: no creará nada "de más", y la carpeta necesaria aparecerá.

Error №3: borrar un archivo sin comprobar.
And veces apetece simplemente llamar a File.Delete sin comprobar si el archivo existe. Eso está permitido — el método no lanzará error si no existe. Pero si la ruta es incorrecta o no tienes permisos — la excepción está asegurada. Mejor manejarlo con antelación.

Error №4: confundir File.Delete y Directory.Delete.
File.Delete sirve solo para archivos, y Directory.Delete para carpetas. Intentar borrar una carpeta con File.Delete es como intentar pulir un ladrillo con un cepillo de dientes: técnicamente posible, pero poco práctico.

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