Dominio del archivo de sistema de C#

Introducción

En C#, el espacio de nombres System.IO proporciona potentes clases para interactuar con el sistema de archivos. Estas clases, como File, FileInfo, Directory y DirectoryInfo, te permiten realizar una variedad de operaciones de archivos, como crear archivos, leer datos, escribir en archivos y verificar si un archivo especificado ya existe en una ruta especificada. Estas clases permiten trabajar con archivos de texto, archivos binarios y archivos de distintas extensiones. Métodos como Create(), Exists() y Delete() permiten a los desarrolladores gestionar archivos y directorios de manera efectiva.

Por ejemplo, la clase File incluye métodos estáticos para verificar si un archivo ya existe, crear un nuevo archivo o abrir archivos en diferentes modos (como leer, escribir o añadir). También puedes usar la clase FileInfo para obtener más detalles sobre un archivo, como su momento de creación o ruta completa. La clase DirectoryInfo te permite trabajar con directorios, obtener archivos o crear nuevos directorios. Estas clases y métodos proporcionan la flexibilidad necesaria para manejar tanto archivos existentes como archivos nuevos, gestionar varios archivos e incluso manejar datos de archivos a nivel de bytes, lo que convierte a C# en una potente herramienta para las operaciones del sistema de archivos.

Tim comienza destacando las potentes funciones de C# para automatizar tareas relacionadas con archivos, como la creación de copias de seguridad, la organización de archivos y la recuperación de información sobre archivos. Introduce el vídeo señalando su objetivo de facilitar el aprendizaje de C# mediante ejemplos prácticos y recursos de formación.

Creación de una aplicación de consola de demostración

Tim empieza desde cero, creando una nueva aplicación de consola llamada "FileSystemDemo" utilizando .NET Framework. Destaca la elección de .NET Framework sobre .NET Core para esta demostración.

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

Configuración de la ruta raíz

Tim establece una variable de ruta raíz que apunta a un directorio específico de su sistema para la demostración.

string rootPath = @"C:\temp\demos\filesystem";

string rootPath = @"C:\temp\demos\filesystem";

Él explica que el símbolo @ permite el uso de barras invertidas en la ruta sin necesidad de escaparlas.

Lectura de todos los directorios de la ruta

Tim demuestra cómo recuperar todos los directorios dentro de la ruta raíz especificada utilizando el método Directory.GetDirectories.

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

Este código imprime las rutas completas de todos los subdirectorios dentro del directorio raíz.

Lectura recursiva de subdirectorios

Para incluir subdirectorios en la búsqueda, Tim añade un patrón de búsqueda y opciones de búsqueda al método GetDirectories.

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

Esta modificación garantiza que todos los subdirectorios anidados se incluyan en la búsqueda.

Lectura de todos los archivos de la ruta

Tim muestra cómo recuperar todos los archivos dentro de la clase de directorio y ruta raíz especificada utilizando el método Directory.GetFiles.

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

Este código imprime las rutas completas de todos los archivos dentro del directorio raíz y sus subdirectorios.

Extracción de nombres de archivo y rutas

Tim explica cómo extraer nombres de archivos y rutas usando la clase Path. Esto incluye obtener el nombre del archivo sin la extensión y el nombre del directorio de cada archivo.

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

Este fragmento de código demuestra cómo extraer e imprimir diferentes partes del mismo archivo en la ruta especificada.

Recuperación de información de archivos

Tim a las (12:10) demuestra cómo obtener información detallada sobre un archivo utilizando la clase FileInfo. Esto incluye obtener el tamaño del archivo, la hora de último acceso, la hora de creación y otros atributos.

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

Este fragmento de código imprime el nombre del archivo y su tamaño en bytes. Tim menciona que se puede convertir este tamaño a kilobytes o megabytes dividiendo por 1024 repetidamente.

Él además explica que la clase FileInfo proporciona otras propiedades útiles:

• LastWriteTime: La última vez que se modificó el archivo.

• LastAccessTime: La última vez que se accedió al archivo.

• CreationTime: El momento de creación del archivo.

• Attributes: Los atributos del archivo, como solo lectura o archivo.

Automating File System Tasks with C

Tim (15:11) explica cómo utilizar C# para automatizar varias tareas del sistema de archivos. Esto puede incluir la creación de directorios, la verificación de la existencia de archivos o directorios y otras tareas repetitivas.

Verificar la existencia de un directorio

Tim muestra cómo verificar si un directorio existe usando el método Directory.Exists. Esto es útil para asegurarse de que los directorios necesarios están en su lugar antes de realizar operaciones.

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

Este código comprueba la existencia de un directorio e imprime un mensaje apropiado.

Creación de un nuevo directorio

Tim explica cómo crear un nuevo directorio usando el método Directory.CreateDirectory. Este método crea todos los directorios y subdirectorios de la ruta especificada si aún no existen.

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

Tim demuestra que este método crea la ruta especificada y sus subdirectorios sin sobrescribir ningún archivo o directorio existente.

Copiar archivos

Tim a las (21:35) demuestra cómo copiar archivos de un directorio a otro usando el método File.Copy. Esto puede ser útil para hacer copias de seguridad u organizar archivos en diferentes carpetas.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

En este ejemplo, los archivos se copian del directorio raíz a subfolderA, y los archivos existentes se sobrescriben debido al parámetro true.

Renombrar archivos durante la copia

Tim también muestra cómo renombrar archivos durante el proceso de copia utilizando un bucle for con un índice.

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

Este código copia archivos al directorio de destino y los renombra secuencialmente como 0.txt, 1.txt, etc.

Gestión de sobrescrituras de archivos

Tim explica cómo manejar archivos existentes sin sobrescrituras y evitar excepciones estableciendo el parámetro de sobrescritura a false. Esto evita que se sobrescriban los archivos existentes y lanza una excepción si un archivo ya existe.

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

Este enfoque ayuda a gestionar de forma segura las copias de archivos y a manejar situaciones en las que los archivos no deben sobrescribirse.

Mover archivos

Tim a las (28:28) demuestra cómo mover archivos usando el método File.Move. A diferencia de File.Copy, el método File.Move no tiene una opción de sobrescritura y generará una excepción si el archivo de destino ya existe.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

Este código mueve archivos del directorio raíz a subfolderA y los elimina del directorio de origen.

Creación de aplicaciones utilitarias

Tim anima a los desarrolladores a pensar en las distintas formas en que pueden utilizar C# para automatizar tareas del sistema de archivos y crear aplicaciones de utilidades. Sugiere empezar con tareas sencillas e ir construyendo gradualmente soluciones de automatización más complejas.

Ejemplos de aplicaciones útiles:

• Limpieza de archivos temporales: Automatiza el proceso de eliminación de archivos temporales para liberar espacio.

• Copias de seguridad en unidades externas: Crear una herramienta de copia de seguridad que copie los archivos importantes en una unidad externa.

• Sincronización de carpetas de proyectos: Sincroniza carpetas de proyectos entre un ordenador y una unidad de memoria USB, garantizando que siempre se realice una copia de seguridad y se restauren los últimos cambios.

Conclusión

La exploración de Tim Corey de las operaciones del sistema de archivos en C# proporciona información práctica sobre la automatización de tareas de archivos y la gestión de directorios. Siguiendo sus ejemplos, los desarrolladores pueden automatizar eficazmente las tareas rutinarias de gestión de archivos y crear aplicaciones de utilidades personalizadas.

Para obtener una comprensión más profunda y ver estos conceptos en acción, le recomiendo que vea el vídeo completo de Tim Corey sobre el Sistema de archivos en C#. Sus detallados recorridos y ejemplos prácticos te ayudarán a afianzar tus conocimientos y te capacitarán para crear tus propias aplicaciones de gestión de archivos.