Formatos de archivos: Textuales y Binarios

1. Archivos de texto

Recuerda: el ordenador guarda todo, absolutamente todo, como unos y ceros (o, si no te asusta la palabra, como una secuencia de bytes). Pero si le das el mismo archivo a dos programas diferentes, no es seguro que ambos reaccionen igual. Por ejemplo, uno puede ver texto normal y el otro un montón de "bytes corruptos". Todo depende del formato del archivo — de cómo se interpretan esos bytes. El formato describe la estructura interna de los datos, las reglas para leerlos y la codificación. Sin conocer el formato, el programa puede no entender qué hay en el archivo.

Un archivo de texto es un archivo donde los datos están representados como texto normal en alguna codificación (lo más común — UTF-8 o, si eres muy hardcore, ASCII). El contenido de este archivo se puede abrir en cualquier editor de texto (por ejemplo, Notepad o VS Code) y leerlo directamente — son líneas de caracteres, no bytes misteriosos de control o estructuras binarias.

Ejemplos típicos

• *.txt — archivos de texto normales, como "to-do.txt" o "best-books.txt".
• *.csv — archivos donde los datos están separados por comas o punto y coma (muy útil para tablas).
• *.json — archivos para intercambiar datos estructurados (por ejemplo, listas de libros).
• *.xml,*.html — para guardar y transferir datos estructurados.

Ejemplo de archivo CSV

Duna;Frank Herbert;1965
1984;George Orwell;1949
El Maestro y Margarita;Mijaíl Bulgákov;1966

Cada línea es un registro separado (por ejemplo, un libro). Los valores dentro de la línea están separados por punto y coma, lo que hace que el archivo sea un ejemplo de CSV (Comma-Separated Values). Comma es como "coma", pero aquí el separador es otro (;). Los símbolos que ves — son los mismos bytes que lee el programa, siempre que sepa cómo interpretar el formato de texto y la codificación del archivo.

¿Cómo trabaja un programa con un archivo de texto?

Solo tienes que abrir el archivo "como texto" y puedes leerlo línea por línea. Ejemplo (te servirá en próximas lecciones):

// Lectura simple de líneas desde un archivo (ya veremos los detalles)
string[] lines = File.ReadAllLines("books.txt");
foreach (string line in lines)
{
    Console.WriteLine(line);
}

Ventajas de los archivos de texto

• Legibles por humanos (human-readable).
• Fácil de editar a mano (incluso en una app básica como Notepad).
• Perfectos para depuración y para intercambiar entre sistemas diferentes.
• Fácil de mover entre plataformas (Windows, Linux, Mac).

Desventajas de los archivos de texto

• No tienen estructura estricta (txt), es fácil meter errores de formato sin querer.
• Ocupán más espacio (por ejemplo, el número 12345 = 5 bytes, pero en binario — 4).
• Datos complejos (como imágenes, audio) son difíciles o imposibles de pasar por texto.
• Rendimiento: más lento para grandes volúmenes de datos.

Es bueno saber

• Diferentes plataformas entienden "fin de línea" de forma distinta: Windows — \r\n, Unix — \n.
• Las codificaciones pueden variar (UTF-8, UTF-16, ANSI, etc.), así que un archivo guardado en un sistema puede verse como "jeroglíficos chinos" en otro (en realidad es solo una mala interpretación de los bytes).

2. Archivos binarios

Un archivo binario es un archivo donde no se guardan caracteres, sino bytes arbitrarios. Pueden significar cualquier cosa: números, estructuras, imágenes, música, incluso código máquina. Prueba a abrir un .exe en el Bloc de notas — ¡verás un montón de galimatías!

Ejemplos típicos

• *.exe, *.dll — archivos ejecutables y librerías.
• *.jpg, *.png, *.gif— imágenes.
• *.mp3, *.wav— archivos de audio.
• *.dat — archivos con datos de usuario arbitrarios.
• Formatos específicos de aplicaciones (*.docx, *.xlsx, etc.) — casi siempre binarios.

¿Cómo está hecho un archivo binario?

Byte a byte, el programa escribe y lee los datos en el formato que necesita. Por ejemplo, un número tipo int se guarda en 4 bytes (32 bits), y una cadena — normalmente es longitud + los bytes de los caracteres en cierta codificación.

En un archivo de texto, el número 12345 — son los bytes que corresponden a los caracteres '1', '2', '3', '4', '5':

En un archivo binario int 12345 (orden de bytes pequeño, little-endian) será así:

(En otras palabras: 12345 = 0x00003039.)

Prueba a guardar el mismo número en texto y en binario — y compara el tamaño de los archivos. El binario será un poco más compacto.

¿Cómo trabaja un programa con un archivo binario?

Flujos especiales (por ejemplo, BinaryReader, BinaryWriter). A diferencia del archivo de texto, aquí tienes que conocer la estructura exacta, si no, no podrás leer los datos.

// Ejemplo de escritura de números en un archivo binario
var writer = new BinaryWriter(File.Open("books.bin", FileMode.Create));

// Por ejemplo, guardamos la codificación: cantidad de caracteres (int), luego los bytes
string title = "Duna";
writer.Write(title.Length); // Guardamos la longitud (int)
writer.Write(title); // Guardamos la cadena (será en UTF-8)
writer.Write(1965); // Guardamos el año (int)

writer.Close(); // cerramos el flujo

Esto es solo un ejemplo. Más sobre archivos binarios te lo cuento en las próximas lecciones.

Ventajas de los archivos binarios

• Compacidad: ocupan menos espacio.
• Se leen y escriben más rápido (sobre todo con grandes volúmenes de datos).
• Puedes guardar estructuras complejas: arrays, objetos anidados, etc.

Desventajas de los archivos binarios

• No legibles por humanos (human-unreadable).
• Si la estructura del archivo cambia, los datos antiguos pueden perderse o "romperse".
• Siempre necesitas instrucciones exactas para analizar el contenido.

3. ¿Qué formato elegir?

Archivos de texto vs binarios

Criterios de elección

• ¿Necesitas que los datos sean legibles por humanos, fáciles de cambiar y depurar? — Usa archivo de texto (por ejemplo, .txt, .csv, .json).
• ¿Los datos son complejos, importa el tamaño y la velocidad? — Formato binario.
• ¿Necesitas intercambiar datos entre diferentes plataformas? — Mejor texto, pero la codificación debe ser estándar (UTF-8).
• ¿La app va a leer y escribir muchos datos y el formato es estricto? — Elige binario.

En nuestra app de consola «Lista de libros» al principio lo ideal es el formato de texto (.csv o .txt). Más adelante, si la estructura se complica o queremos más velocidad, podemos mirar archivos binarios o pasar a JSON/XML.

4. Matices útiles

¿Dónde ves archivos de texto y binarios en la vida real?

Archivos de texto:

• Configuraciones de programas (a menudo en .ini o .json).
• Scripts, logs, notas.
• Archivos de importación/exportación (datos para intercambiar entre apps).

Archivos binarios:

• Programas, juegos, librerías (nadie mira ahí así porque sí).
• Grandes bases de datos y archivos comprimidos (por ejemplo, .mdb, .zip).
• Media: música, fotos, vídeo.

Leer todo el archivo de una vez (texto):

string allText = File.ReadAllText("books.txt");
// Ahora allText — un string gigante con todo el contenido

Por líneas (óptimo para listas):

string[] lines = File.ReadAllLines("books.txt");
foreach (string line in lines)
{
    // Puedes dividir la línea en partes
    string[] parts = line.Split(';');
    // parts[0] — título, parts[1] — autor, parts[2] — año
}

Lectura binaria — estrictamente según la estructura

var reader = new BinaryReader(File.Open("books.bin", FileMode.Open));

int count = reader.ReadInt32(); // Cuántos libros
for (int i = 0; i < count; i++)
{
    string title = reader.ReadString();
    string author = reader.ReadString();
    int year = reader.ReadInt32();
    // ¡Ahora puedes reconstruir el registro!
}

reader.Close();

5. Ejemplo práctico: creamos un archivo con libros

Guardamos datos en un archivo de texto

Vamos a guardar cada libro en una línea con el formato:
título;autor;año de la primera edición

// Lista de libros que queremos guardar
var books = new List<(string Title, string Author, int Year)>
{
    ("Duna", "Frank Herbert", 1965),
    ("1984", "George Orwell", 1949),
    ("El Maestro y Margarita", "Mijaíl Bulgákov", 1966)
};

// Guardamos en archivo de texto
var writer = new StreamWriter("books.txt");
foreach (var book in books)
    writer.WriteLine($"{book.Title};{book.Author};{book.Year}");

writer.Close();

Puedes abrir books.txt en el Bloc de notas y ver todos los datos.

Guardamos datos en un archivo binario

Ahora probamos lo mismo, pero más compacto (aunque no legible para humanos):

var writer = new BinaryWriter(File.Open("books.bin", FileMode.Create));

writer.Write(books.Count); // Guardamos la cantidad de libros
foreach (var book in books)
{
    writer.Write(book.Title); // Cadena - se guarda como: longitud + bytes
    writer.Write(book.Author); // Cadena
    writer.Write(book.Year); // Año (int)
}

writer.Close();

Si intentas abrir books.bin en un editor de texto, verás caos: un montón de símbolos ilegibles. Es normal. Los archivos binarios no están hechos para que los lea una persona — solo el programa que sabe exactamente cómo se guardó ese archivo puede procesarlo bien.

6. Errores típicos al trabajar con formatos

Si intentas leer un archivo binario como si fuera de texto, tendrás un "batiburrillo" de símbolos o incluso un error. Igual, si abres un archivo de texto como binario esperando una estructura estricta — tendrás problemas.

El error más común: no coincidir la estructura de los datos y el orden de lectura/escritura. Por ejemplo, primero guardaste el año, luego el título, pero al leerlo lo haces al revés — tendrás información incorrecta. ¡Sigue siempre el mismo orden de operaciones!

Muy a menudo los programadores "echan un vistazo" al archivo de texto para comprobar la lógica de guardado y carga — justo para eso los formatos de texto son tan cómodos al principio. El binario es para escenarios más avanzados, o cuando quieres ocultar los detalles de almacenamiento al usuario.

2

Tarea

C# SELF, nivel 35, lección 1

Bloqueada

Escritura y lectura de un archivo de texto

Escritura y lectura de un archivo de texto

Abrir