CodeGym /Cursos /C# SELF /Trabajo con XmlSerializer para serializar en XML

Trabajo con XmlSerializer para serializar en XML

C# SELF
Nivel 44, Lección 2
Disponible

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:

  • [XmlElement]
    — renombra el elemento.
  • [XmlAttribute]
    — convierte el campo en un atributo XML en vez de elemento.
  • [XmlIgnore]
    — excluye la propiedad de la serialización.
  • [XmlArray]
    y
    [XmlArrayItem]
    — controlan el empaquetado de colecciones.

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
[XmlAttribute]
Convierte la propiedad en un atributo XML
<Player Name="Aragorn">...</Player>
[XmlElement]
Cambia el nombre de la etiqueta
<HP>100</HP>
en lugar de
<Health>100</Health>
[XmlIgnore]
Excluye completamente la propiedad de la serialización —
[XmlArray]
Cambia el nombre del "envoltorio" de la colección
<Heroes> ... </Heroes>
[XmlArrayItem]
Cambia el nombre del elemento de la colección
<Hero>...</Hero>

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

2
Tarea
C# SELF, nivel 44, lección 2
Bloqueada
Serialización y deserialización de una lista de objetos
Serialización y deserialización de una lista de objetos
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION