Manipulating files and directories

En el capítulo previo, vimos la lectura y escritura de texto con archivos simples. Usamos la clase File para esto, pero esta hace mucho más que sólo leer y escribir. Cuando es combinada con la clase Directory, podemos ejecutar casi cualquier operación del sistema de archivos, como renombrar, mover, eliminar, entre otras.

Este capítulo proveerá numerosos ejemplos para hacer justo estas cosas. Las explicaciones serán limitadas, ya que los métodos usados con muy simples y fáciles de usar. Debe tomar en cuenta dos cosas: primero, asegurese de imporat el espacio de nombre System.IO como esto:

using System.IO;

También, considere que aquí no estamos haciendo manejo de excepciones. Checaremos que los archivos y directorios existan antes de usarlos, pero no hay manejo de excepciones, así que en caso de que algo falle, la aplicación se estrellará. El manejo de excepciones en general es una buena idea cuando se hacen operciones de entrada salida. Para más información, por favor lea el capítulo de manejo de excepciones en este tutorial.

En todos los ejemplos, usamos un nombres simples de archivos y directorios, los cuales tienen que existir en el mismo directorio que el archivo EXE generado de su aplicación. En la configuración de proyecto puede ver donde es generado su archivo EXE.

Eliminando un archivo

if(File.Exists("test.txt"))
{
    File.Delete("test.txt");
    if(File.Exists("test.txt") == false)
    Console.WriteLine("File deleted...");
}
else
    Console.WriteLine("File test.txt does not yet exist!");
Console.ReadKey();

Eliminando un directorio

if(Directory.Exists("testdir"))
{
    Directory.Delete("testdir");
    if(Directory.Exists("testdir") == false)
    Console.WriteLine("Directory deleted...");
}
else
    Console.WriteLine("Directory testdir does not yet exist!");
Console.ReadKey();

Si testdir no está vacío, recibirá una excepción. ¿Porqué? Por que este versión de Delete() en la clase Directory trabaja sólo en directorios vacíos. Aunque es muy fácil cambiar:

Directory.Delete("testdir", true);

El parámetro extra se asegura que el método Delete() sea recursivo, esto significa que atravesará los subdirectorios y borrará los archivos de estos, antes de borrar los directorios.

Renombrando un archivo

if(File.Exists("test.txt"))
{
    Console.WriteLine("Please enter a new name for this file:");
    string newFilename = Console.ReadLine();
    if(newFilename != String.Empty)
    {
    File.Move("test.txt", newFilename);
    if(File.Exists(newFilename))
    {
        Console.WriteLine("The file was renamed to " + newFilename);
        Console.ReadKey();
    }
    }
}

Notará que usamos el método Move() para renombrar el archivo. ¿Porqué no un método Rename()? Por que no hay tal método, ya que mover y renombrar es esencialmente la misma cosa.

Renombrando un directorio

Hacer lo mismo con un directorio es así de fácil:

if(Directory.Exists("testdir"))
{
    Console.WriteLine("Please enter a new name for this directory:");
    string newDirName = Console.ReadLine();
    if(newDirName != String.Empty)
    {
    Directory.Move("testdir", newDirName);
    if(Directory.Exists(newDirName))
    {
        Console.WriteLine("The directory was renamed to " + newDirName);
        Console.ReadKey();
    }
    }
}

Creando un nuevo directorio

Crear un nuevo directrorio es también fácil - sólo use el método CreateDirectory() en la clase Directory , como en este ejemplo:

Console.WriteLine("Please enter a name for the new directory:");
string newDirName = Console.ReadLine();
if(newDirName != String.Empty)
{
    Directory.CreateDirectory(newDirName);
    if(Directory.Exists(newDirName))
    {
    Console.WriteLine("The directory was created!");
    Console.ReadKey();
    }
}

Leyendo y Escribiendo Archivos

Como un ejemplo final, le mostraré como la clase File hace múy fácil la lectura y escritura de un archivo. Esto puede hacerse en muchas formas en C#, pero los métodos Read* y Write*, encontrados en la clase File, son probablemente la forma más fácil de usar. Hay tres versiones: WriteAllBytes(), WriteAllLines() y WriteAllText(), con sus correspondientes métodos Read. El más simple de usar es el último, el cual tomará una cadena simple como su entrada. Permítame ilustrar como trabajan con un ejemplo simple:

string fileContents = "John Doe & Jane Doe sitting in a tree...";
File.WriteAllText("test.txt", fileContents);

string fileContentsFromFile = File.ReadAllText("test.txt");
Console.WriteLine(fileContentsFromFile);

¡Note que tan pocas líneas de código necesito para escribir algo en un archivo y luego leerlo de regreso! El primer parámetro de ambos métodos es la trayectoria a donde el texto debe ser escrito y leído. Normalmente, especificaría aquí una trayectoria completa, pero para hacer el ejemplo más claro, sólo especifiqué una nombre de archivo, resultado en que el archivo sea escrito en el mismo directorio que el archivo EXE.

Resumen

Como puede ver, las clases File y Directory son una gran ayuda cuando necesita trabajr con archivos y directorios. Pueden ayudarle a hacer la mayoría de las operaciones necesarias, y si necesita hace aún cosas más avanzadas, estas clases y sus métodos servirán usualmente como estupendos bloques de construcción para expandirse.