1. Introducción
XML — abreviatura de eXtensible Markup Language. Imagínate un JSON muy estricto y hablador, capaz de repetir muchas veces «¡soy estructurado, créeme!». XML es un formato de texto donde los datos se envuelven con etiquetas:
<Player>
<Name>Aragorn</Name>
<Health>100</Health>
</Player>
¿Por qué serializar objetos a XML hoy en día?
- XML sigue usándose mucho en integraciones entre sistemas grandes (a menudo "legacy"), donde se necesita no solo estructura sino validación con esquemas estrictos (XSD).
- XML se usa a menudo en configuraciones corporativas (por ejemplo, App.config y Web.config en versiones antiguas de .NET).
- XML encaja perfecto cuando importa la "autodescripción" de la estructura de datos.
Dato curioso: XML fue diseñado desde el inicio para ser lo más "extensible" y validable posible; de ahí su nombre. Se puede validar contra un esquema, algo que JSON no ofrece "de serie".
XmlSerializer: el protagonista
En .NET la clase que se encarga de serializar objetos a XML es System.Xml.Serialization.XmlSerializer.
- Convierte las propiedades públicas y campos de un objeto en elementos XML, y viceversa: a partir del XML reconstruye el objeto.
- Funciona solo con tipos y miembros públicos.
- No serializa campos y propiedades privados — ¡solo lo público!
- Requiere que la clase serializable tenga un constructor sin parámetros.
Atención: Si tu clase no cumple estos requisitos, XmlSerializer no podrá trabajar con ella — lanzará una excepción al serializar o deserializar.
2. Ejemplo simple — serializar un objeto a XML
Vamos a ver cómo serializar nuestra clase favorita Player a XML.
Paso 1. Definimos la clase
public class Player
{
public string Name { get; set; }
public int Health { get; set; }
public bool IsAlive { get; set; }
// Importante: se necesita un constructor público sin parámetros!
public Player() { }
// Opcional: para comodidad
public Player(string name, int health, bool isAlive)
{
Name = name;
Health = health;
IsAlive = isAlive;
}
}
Paso 2. Serializamos a archivo
using System.Xml.Serialization;
Player aragorn = new Player("Aragorn", 100, true);
// 1. Creamos el serializer para el tipo Player
XmlSerializer serializer = new XmlSerializer(typeof(Player));
// 2. Abrimos el archivo para escribir (se creará si no existe)
using FileStream fs = new FileStream("player.xml", FileMode.Create);
// 3. Serializamos el objeto a XML
serializer.Serialize(fs, aragorn);
Resultado (player.xml):
<?xml version="1.0"?>
<Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>Aragorn</Name>
<Health>100</Health>
<IsAlive>true</IsAlive>
</Player>
Esquema visual del proceso más básico
Objeto en memoria ---> XmlSerializer.Serialize() ---> archivo XML en disco
3. Deserialización — "reanimamos" un objeto desde XML
Cuando necesitas leer un objeto serializado antes, el proceso es el inverso:
using FileStream fs = new FileStream("player.xml", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(Player));
Player player = (Player)serializer.Deserialize(fs);
Console.WriteLine($"Nombre: {player.Name}, Salud: {player.Health}, Vivo: {player.IsAlive}");
Como resultado el programa mostrará: Nombre: Aragorn, Salud: 100, Vivo: True
4. Serializar a cadena — no solo a archivo
Serializar a cadena
No siempre quieres serializar a un archivo. A veces necesitas enviar el XML como cadena por la red o mostrarlo en pantalla.
using System.IO;
using System.Xml.Serialization;
Player player = new Player("Frodo", 42, true);
XmlSerializer serializer = new XmlSerializer(typeof(Player));
StringWriter stringWriter = new StringWriter();
serializer.Serialize(stringWriter, player);
string xmlString = stringWriter.ToString();
Console.WriteLine(xmlString); // ¡Toda la cadena XML en pantalla!
Deserializar desde cadena
De forma similar puedes deserializar no desde un archivo sino desde una cadena:
string xml = "<Player Name=\"Frodo\"><HP>42</HP></Player>";
XmlSerializer serializer = new XmlSerializer(typeof(Player));
using StringReader stringReader = new StringReader(xml);
Player frodo = (Player)serializer.Deserialize(stringReader);
Console.WriteLine(frodo.Name); // Frodo
5. Personalizar el XML: atributos para controlar la estructura
A veces el comportamiento por defecto no te vale. El XML queda demasiado verboso o las etiquetas no coinciden con lo que necesitas. Ahí entran varios atributos "mágicos" que le dicen al serializer cómo representar los miembros de la clase.
Los más útiles:
— renombra el elemento.[XmlElement]
— convierte el campo en un atributo XML en vez de elemento.[XmlAttribute]
— excluye la propiedad de la serialización.[XmlIgnore]
y[XmlArray]
— controlan el empaquetado de colecciones.[XmlArrayItem]
Ejemplo de uso:
public class Player
{
[XmlAttribute]
public string Name { get; set; }
[XmlElement("HP")]
public int Health { get; set; }
[XmlIgnore]
public bool IsTempSessionPlayer { get; set; }
}
XML resultante:
<Player Name="Aragorn">
<HP>100</HP>
</Player>
Tabla de los atributos principales para la serialización
| Atributo | En qué afecta | Ejemplo de uso |
|---|---|---|
|
Convierte la propiedad en un atributo XML | |
|
Cambia el nombre de la etiqueta | en lugar de |
|
Excluye completamente la propiedad de la serialización | — |
|
Cambia el nombre del "envoltorio" de la colección | |
|
Cambia el nombre del elemento de la colección | |
Ejemplo de serialización compleja de una colección:
public class GameWorld
{
[XmlArray("Heroes")]
[XmlArrayItem("Hero")]
public List<Player> Players { get; set; } = new List<Player>();
}
XML:
<GameWorld>
<Heroes>
<Hero Name="Legolas">
<HP>90</HP>
</Hero>
<!-- ... -->
</Heroes>
</GameWorld>
¡Más sobre personalización de XML lo verás en las siguientes lecciones! :P
GO TO FULL VERSION