Concepto de archivo, sistema de archivos y ruta

1. Introducción

Archivo — es simplemente un bloque de datos que físicamente se guarda en algún tipo de almacenamiento: disco duro, SSD, pendrive, ¡o incluso un disquete (¡saludos a tu abuelo!)! Para el usuario, un archivo es algo que puedes abrir, leer, modificar y guardar.

En programación, un archivo es una secuencia de bytes con un nombre y una ubicación, y para ti, como programador, es un objeto que tiene nombre, ruta (como una dirección), tamaño, fecha de creación, etc. Lo más importante: un archivo es un almacenamiento persistente de datos. Todo lo que pasa en la memoria después de arrancar el programa normalmente desaparece al cerrarlo, pero el archivo — se queda.

¿Qué es un sistema de archivos?

Sistema de archivos — es la forma de guardar y organizar archivos en el disco. Responde a preguntas como: dónde y cómo buscar un archivo, quién tiene acceso, cómo están organizadas las carpetas (directorios), cómo encontrar el nombre y el contenido del archivo.

Imagina un armario enorme con muchos cajones. En cada cajón puede haber carpetas, y en cada carpeta — documentos (archivos). Para encontrar tus apuntes de C#, tienes que abrir el armario, buscar el cajón correcto, sacar la carpeta y dentro — la hoja que buscas. Así es como el sistema de archivos organiza la info.

Sistemas de archivos populares

• NTFS — el sistema de archivos "nativo" de Windows.
• FAT32, exFAT — para pendrives, tarjetas SD, discos externos.
• EXT4 — muy usado en Linux.
• APFS, HFS+ — macOS.

Para un programador de C# esto normalmente no importa mucho: .NET esconde los detalles y tú trabajas con la abstracción "archivo/carpeta". Pero a veces viene bien saber algo. Por ejemplo, en NTFS puedes usar espacios y muchos símbolos especiales en el nombre del archivo, pero en FAT32 — no.

2. Cómo funcionan los directorios (carpetas)

Directorio (o carpeta) — es un tipo especial de archivo que contiene listas de otros archivos y/o directorios. El árbol de directorios (jerarquía de archivos) — es ese camino típico desde la raíz hasta el archivo: por ejemplo, C:\Users\Ivan\Documents\MyFile.txt.

• Raíz — es el principio del disco (C:\).
• Dentro — carpetas (subcarpetas), donde hay archivos o más carpetas.

Aquí tienes una visualización sencilla:

C:\
 └── Users\
     └── Ivan\
         ├── Documents\
         │    └── MyFile.txt
         └── Pictures\
              └── Cat.jpg

3. ¿Qué es una ruta de archivo (file path)?

Ruta de archivo — es la "dirección" de un archivo en el árbol de carpetas. Con ella puedes encontrar exactamente el archivo o carpeta que buscas.

Ruta absoluta y relativa

• Ruta absoluta: empieza desde la raíz del sistema de archivos.
  Windows: C:\Users\Ivan\Documents\MyFile.txt
  Linux/macOS: /home/ivan/Documents/MyFile.txt
• Ruta relativa: empieza desde la ubicación actual (directorio actual).
  Por ejemplo, si tu programa se ejecuta desde la carpeta C:\Users\Ivan, entonces la ruta relativa Documents\MyFile.txt te lleva al mismo archivo.

Directorio actual — es un concepto especial: es el "punto de partida" para todas las rutas relativas. Al arrancar el programa normalmente es la carpeta donde está el .exe, o donde abriste la consola.

Esquema: Ruta absoluta y relativa

Ruta absoluta                                 Ruta relativa

C:\Projects\MyApp\logs\output.txt              logs\output.txt
└─ Raíz del disco (C:)                         └─ Relativo a donde se ejecutó MyApp

Separadores en rutas: \ y /

En Windows se usa la barra invertida (\), y en Linux/macOS — normalmente la barra normal (/).

El .NET moderno soporta ambos, pero intenta no mezclarlos en el mismo proyecto. Para construir rutas usa siempre el API especial (interfaz de programación de aplicaciones), no pegues cadenas a mano.

4. Cómo ve el archivo el programa

En .NET tienes un montón de herramientas para trabajar con archivos. Las principales:

• System.IO.File: métodos estáticos para leer, escribir, borrar, comprobar si existe un archivo, etc.
• System.IO.Directory: métodos parecidos para trabajar con carpetas.
• System.IO.FileInfo y System.IO.DirectoryInfo: envoltorios orientados a objetos con acceso a metadatos del archivo/carpeta.
• System.IO.Path: clase ayudante para trabajar con rutas (unir rutas, sacar la extensión, nombre, etc).

Unos ejemplos

Comprobar si existe un archivo

using System.IO;

if (File.Exists("data.txt"))
{
    Console.WriteLine("¡Archivo encontrado!");
}
else
{
    Console.WriteLine("¡Archivo no encontrado!");
}

Obtener el tamaño de un archivo

var info = new FileInfo("data.txt");
Console.WriteLine($"Tamaño del archivo: {info.Length} bytes");

Vamos a ver cómo funcionan todos estos ejemplos en las próximas lecciones. Por ahora — solo mira y disfruta :).

5. Detalles útiles

Metadatos del archivo: nombre, extensión, tamaño, fechas, etc.

Cuando trabajas con un archivo, no solo importa su contenido — también está el "pasaporte del archivo":

• Nombre — cómo se llama el archivo para la gente.
• Extensión — .txt, .jpg, .exe, .cs y más: ayuda (¡a veces!) a saber qué hay dentro.
• Tamaño — número de bytes.
• Fecha de creación/modificación — puedes saber cuándo apareció el archivo o cuándo se cambió por última vez.
• Atributos — por ejemplo: solo lectura, oculto, de sistema.

En .NET para esto son muy útiles las clases FileInfo, DirectoryInfo (lo veremos en otra lección).

Extensiones de archivo y formatos

Extensión de archivo — es solo la parte del nombre después del punto. Por ejemplo, en document.txt la extensión es txt. El sistema operativo usa la extensión para saber con qué "abrir" el archivo (por ejemplo, .jpg — un programa de imágenes, .xls — Excel, etc).

Pero para el programador la extensión — es solo una pista. El formato real del archivo solo lo define su contenido. Puedes, por ejemplo, abrir MyCat.jpg como texto — y verás un montón de "caracteres raros" (símbolos que no entiendes, pero no una imagen). Así que recuerda: la extensión — no es garantía, solo una convención.

Cómo funciona la lectura y escritura de archivos: conceptos básicos

Un archivo — es una secuencia de bytes. Trabajar con archivos en C# normalmente significa:

• Abrir el archivo para leer o escribir (o ambas cosas).
• Leer datos a la memoria.
• Escribir nuevos datos al disco.
• Cerrar el archivo — muy importante, si no, bloqueas el recurso del sistema (y alguien no podrá borrar el archivo mientras lo tengas abierto).

Las APIs modernas de .NET cuidan de ti: por ejemplo, la clase File puede abrir, leer y cerrar el archivo de una vez. Pero si trabajas con streams (Stream) y archivos grandes, tienes que tomártelo en serio (de eso hablaremos en otras lecciones).

Qué hay que saber sobre la multiplataforma

Casi todo el C# moderno funciona igual en Windows, Linux y macOS. Pero hay detalles. El más típico — la diferencia en los separadores (\ vs /), y también límites en la longitud del nombre y símbolos prohibidos.

Por eso APIs como Path.Combine y métodos de System.IO.Path — son tus mejores amigos. Ellos "pegan" la ruta bien en cualquier SO. Nunca hagas esto:

var filePath = "C:\\Users\\Ivan\\data.txt"; // ¡Solo para Windows!

Mejor así:

var filePath = Path.Combine("Users", "Ivan", "data.txt");

¿Cómo saber el directorio de trabajo actual?

A veces es importante saber dónde se van a guardar tus archivos. Para eso hay una clase especial:

string currentDir = Environment.CurrentDirectory;
Console.WriteLine($"Directorio actual: {currentDir}");

Por cierto, si quieres dejar que el usuario elija la ruta, usa diálogos de selección de archivo/carpeta o argumentos de línea de comandos.