1. Introducción
Recordatorio: La serialización es una forma de guardar el estado de un objeto en forma de cadena, archivo o flujo, para que más tarde puedas restaurar ese objeto (deserializarlo) — y volver a tener un objeto con los mismos datos.
Situación típica:
1) Tienes un objeto, por ejemplo, un usuario con nombre y edad.
2) Necesitas guardarlo — enviarlo por la red, escribirlo en un archivo o, por ejemplo, en formato JSON.
3) Luego sacas los datos de la cadena/archivo — ¡y recuperas el objeto!
En C# se hace literalmente en un par de líneas. Vamos a ver cómo.
Nuestra aplicación
Estamos desarrollando una pequeña aplicación «Gestor de contactos». Supongamos que tenemos la clase Person, que queremos serializar.
public class Person
{
// ¡Las propiedades públicas son necesarias para la serialización!
public string Name { get; set; }
public int Age { get; set; }
// El constructor sin parámetros es obligatorio para XmlSerializer
public Person() { }
public Person(string name, int age)
{
Name = name;
Age = age;
}
}
Si no conoces esta sintaxis, no te preocupes — más adelante en el curso veremos clases y propiedades en detalle. Ahora considéralo como un modelo de datos para experimentar. Fíjate: las propiedades públicas Name y Age — son importantes para la serialización, y para XmlSerializer se necesita un constructor público sin parámetros.
2. Serialización a JSON con System.Text.Json
Ejemplo básico
Lo prometido es deuda — ¡aquí va! Así se ve la serialización a JSON:
using System;
using System.Text.Json;
Person person = new Person("Alicia", 28);
// Serialización: convertimos el objeto a una cadena JSON
string json = JsonSerializer.Serialize(person);
Console.WriteLine("JSON:");
Console.WriteLine(json);
¿Qué aparecerá en pantalla?
JSON:
{"Name":"Alicia","Age":28}
Fácil: objeto → JSON. ¡Ahí está la magia!
Deserialización — devolvemos todo atrás
Ahora hacemos la operación inversa — desde una cadena JSON recuperamos el objeto:
string json = "{\"Name\":\"Bob\",\"Age\":35}";
// Deserialización: restauramos un objeto de tipo Person desde la cadena JSON
Person restored = JsonSerializer.Deserialize<Person>(json);
Console.WriteLine("Objeto restaurado:");
Console.WriteLine($"Nombre: {restored.Name}, edad: {restored.Age}");
Resultado:
Objeto restaurado:
Nombre: Bob, edad: 35
Fíjate: si la estructura de datos no coincide (por ejemplo, falta una propiedad), el campo correspondiente permanecerá con el valor por defecto (null para tipos referencia, 0 para números, etc.).
3. Serialización/deserialización a XML con XmlSerializer
Serialización a XML — primera mirada
using System;
using System.IO;
using System.Xml.Serialization;
Person person = new Person("Kate", 22);
// Creamos el XmlSerializer para el tipo Person
var serializer = new XmlSerializer(typeof(Person));
// Escribimos el XML en un archivo
using (var stream = new FileStream("person.xml", FileMode.Create))
{
serializer.Serialize(stream, person);
// El stream se cerrará automáticamente al final del bloque using
}
Console.WriteLine("¡Archivo XML creado!");
En el archivo person.xml aparecerá algo como esto:
<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>Kate</Name>
<Age>22</Age>
</Person>
Punto importante:
Para serializar en un archivo se usa un flujo (Stream, por ejemplo, FileStream). Si quieres serializar a una cadena (por ejemplo, para enviar por la red), usa StringWriter:
var serializer = new XmlSerializer(typeof(Person));
using (var sw = new StringWriter())
{
serializer.Serialize(sw, person);
string xmlString = sw.ToString();
Console.WriteLine(xmlString);
}
Deserialización desde XML
using (var stream = new FileStream("person.xml", FileMode.Open))
{
// ¡No olvides castear al tipo correcto!
Person restored = (Person)serializer.Deserialize(stream);
Console.WriteLine($"Nombre: {restored.Name}, edad: {restored.Age}");
}
Otra vez: XmlSerializer requiere que la clase a serializar tenga un constructor público por defecto (sin parámetros).
4. Trabajar con archivos y cadenas: ¿qué elegir?
En la vida real la serialización puede ir directamente a una cadena (para envío por red/almacenamiento en BD) o a un archivo (para almacenamiento a largo plazo).
Serializar a cadena (por ejemplo, para pasar por un API):
- JSON: usamos JsonSerializer.Serialize(obj).
- XML: a través de StringWriter.
Serializar a archivo (por ejemplo, para exportar/backup):
- JSON: guardamos la cadena en un archivo con las funciones habituales de I/O.
- XML: escribimos directamente en el stream con XmlSerializer.
Ejemplo: serializar a archivo y volver (JSON)
using System.IO;
using System.Text.Json;
Person person = new Person("Tom", 42);
// Serialización a cadena
string json = JsonSerializer.Serialize(person);
// Escribir en archivo
File.WriteAllText("contact.json", json);
// Leer desde archivo
string readJson = File.ReadAllText("contact.json");
Person restored = JsonSerializer.Deserialize<Person>(readJson);
Console.WriteLine($"{restored.Name}, edad: {restored.Age}");
5. Comparación JSON vs XML
Visualización del proceso
Para no liarnos, aquí tienes el esquema del proceso de serialización y deserialización:
flowchart LR
A[Objeto] -- serialización --> B[Cadena/Archivo/Flujo]
B -- deserialización --> C[Objeto]
A -. JSON o XML .-> B
B -. JSON o XML .-> C
Puedes imaginar que la serialización es "hacer la maleta" y la deserialización es "deshacerla" en casa.
Tabla comparativa
| Funcionalidad | JSON (System.Text.Json) | XML (XmlSerializer) |
|---|---|---|
| Lectura/escritura en cadena | ++ | + |
| Lectura/escritura en archivo | ++ | ++ |
| Requiere constructor sin parámetros | No | Sí |
| Legibilidad para humanos | ++ | + |
| Esquema estricto de datos (validación) | - | ++ |
| Flexibilidad (atributos de personalización) | + | ++ |
| Rendimiento | ++ | + |
| Compatibilidad con internet | ++ | + |
++ — muy bien, + — normal, - — no soportado
6. Cómo añadir serialización a nuestra aplicación
Supongamos que en el "Gestor de contactos" apareció la opción de guardar la lista de contactos en un archivo y recuperarla.
Contexto: tenemos una lista de contactos (List<Person>).
List<Person> contacts = new List<Person>
{
new Person("Basil", 30),
new Person("Peter", 25),
new Person("Mary", 27)
};
// Guardamos todos los contactos — serializamos a JSON
string jsonContacts = JsonSerializer.Serialize(contacts);
File.WriteAllText("contacts.json", jsonContacts);
// Restauramos la lista de contactos
string readContactsJson = File.ReadAllText("contacts.json");
List<Person> restored = JsonSerializer.Deserialize<List<Person>>(readContactsJson);
foreach (var c in restored)
{
Console.WriteLine($"{c.Name}, edad: {c.Age}");
}
Lo mismo se puede hacer con XML, pero tiene sus particularidades. Para serializar colecciones con XmlSerializer normalmente envuelves la lista en una clase contenedora (elemento raíz) — así es más fácil controlar el formato y los nombres de los elementos.
7. Errores típicos al serializar y deserializar
Error nº1: desajuste de tipos al serializar y deserializar.
Si serializaste List<Person> — debes deserializar también en List<Person>, no en List<object> o IEnumerable<Person>. Si no, obtendrás un error o resultados inesperados.
Error nº2: intentar serializar campos y propiedades no públicos.
Los serializadores típicos (JsonSerializer, XmlSerializer) trabajan con miembros públicos. Si una propiedad no tiene getter/setter público, su valor puede no aparecer en el JSON/XML, y te preguntarás por qué está null.
Error nº3: ausencia de constructor sin parámetros.
Para XmlSerializer el constructor público por defecto es obligatorio. Si no existe — habrá una excepción al deserializar.
Error nº4: mal entendimiento de las referencias entre objetos.
Si un objeto contiene referencia a otro, la serialización va "por valor" (como objeto anidado). Las referencias como tal no se guardan, lo que puede causar duplicación de datos o problemas con referencias cíclicas.
Error nº5: intentar mezclar formatos de serialización.
XML y JSON son formatos distintos y usan serializadores distintos. No puedes pasar una cadena JSON a XmlSerializer y viceversa — dará error.
GO TO FULL VERSION