CodeGym /Cursos /C# SELF /Lectura y escritura de XML: XmlSerializer

Lectura y escritura de XML: XmlSerializer

C# SELF
Nivel 48, Lección 0
Disponible

1. Introducción

XML (eXtensible Markup Language) — un lenguaje de marcado extensible, un formato popular para almacenar e intercambiar datos estructurados complejos. A diferencia de JSON, XML no es tan conciso, pero sigue usándose mucho en banca, intercambio entre servicios estatales, documentos e integraciones con 1C, SAP, Oracle, etc. Algunos datos en Windows y .NET (por ejemplo, configs) todavía se guardan en formato XML.

Visualmente XML se parece a HTML, pero sin un conjunto fijo de etiquetas como <body> o <div> — tú defines la estructura de tus elementos. Ejemplo:

<Person>
  <FirstName>Iván</FirstName>
  <LastName>Petrov</LastName>
  <Age>30</Age>
</Person>

Fundamentos de XML y correspondencia con objetos C#

A diferencia de JSON, en XML no hay tipos especiales para arrays o booleanos — todo se representa con elementos y atributos. Las estructuras tipo lista se implementan como elementos repetidos con el mismo nombre.

Para trabajar cómodamente con XML en C# se usa el mecanismo de serialización/deserialización mediante XmlSerializer.

Serialización — convertir un objeto C# en una cadena XML. Deserialización — el proceso inverso: obtener un objeto C# desde XML.

Funciona “listo para usar” si tus clases cumplen ciertos requisitos — los veremos abajo.

¿Por qué usar XmlSerializer?

XmlSerializer — herramienta estándar de .NET (namespace System.Xml.Serialization) para convertir objetos a XML y viceversa. Es sencillo, type-safe y útil para importar/exportar datos, configs, intercambio entre sistemas e integraciones con servicios estatales.

2. Ejemplo: serialización de un objeto

Supongamos que tenemos el modelo de usuario:

public class User
{
    public string FirstName { get; set; }
    public string LastName  { get; set; }
    public int Age          { get; set; }
}

Serializamos el objeto a XML:

using System.Xml.Serialization;

User user = new User { FirstName = "Iván", LastName = "Petrov", Age = 30 };
// Para la serialización se necesita el tipo
XmlSerializer serializer = new XmlSerializer(typeof(User));

// Escribimos el XML en un archivo
using FileStream fs = new FileStream("user.xml", FileMode.Create);
serializer.Serialize(fs, user);

¿Qué pasa aquí?

- Creamos un objeto de la clase User.
- Creamos una instancia de XmlSerializer para el tipo User.
- Abrimos un archivo con FileStream.
- Llamamos al método Serialize(), que convierte el objeto a XML y lo escribe en el archivo.

Contenido del archivo user.xml:

<?xml version="1.0"?>
<User xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <FirstName>Iván</FirstName>
  <LastName>Petrov</LastName>
  <Age>30</Age>
</User>

Así de simple — mínimo código y ya tienes el XML.

3. Deserialización: leemos el XML de vuelta al objeto

Leemos el XML creado y restauramos el objeto C#:

// Abriendo el archivo XML
using FileStream fs = new FileStream("user.xml", FileMode.Open);
User? loadedUser = serializer.Deserialize(fs) as User;
Console.WriteLine($"{loadedUser?.FirstName} {loadedUser?.LastName}, edad: {loadedUser?.Age}");

El método Deserialize() devuelve object, por eso hacemos el cast a User (usando as). Si el archivo es correcto y coincide con el modelo — el objeto se restaurará completamente.

4. Cómo funciona la serialización: características típicas

La serialización a XML requiere cumplir algunas reglas:

• La clase para serializar debe tener un constructor público por defecto (public sin parámetros).

• Las propiedades serializables son públicas: necesitan getter y setter. Los miembros privados se ignoran.

• No funcionan propiedades solo de lectura, ni propiedades estáticas o abstractas.

Si rompes las reglas obtendrás InvalidOperationException con un mensaje como "XmlSerializer cannot serialize this type".

5. Serialización de colecciones: arrays y listas

Si necesitas serializar varios usuarios — usa una clase contenedora:

public class UserList
{
    public List<User> Users { get; set; } = new List<User>();
}

Creamos la colección y la serializamos:

UserList users = new UserList
{
    Users = new List<User>
    {
        new User { FirstName = "Iván", LastName = "Petrov", Age = 30 },
        new User { FirstName = "María", LastName = "Ivanova", Age = 25 }
    }
};

XmlSerializer serializer = new XmlSerializer(typeof(UserList));
using FileStream fs = new FileStream("users.xml", FileMode.Create);
serializer.Serialize(fs, users);

Obtendremos el XML:

<?xml version="1.0"?>
<UserList xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Users>
    <User>
      <FirstName>Iván</FirstName>
      <LastName>Petrov</LastName>
      <Age>30</Age>
    </User>
    <User>
      <FirstName>María</FirstName>
      <LastName>Ivanova</LastName>
      <Age>25</Age>
    </User>
  </Users>
</UserList>

¿Se puede serializar simplemente List<User>? Sí, pero el elemento raíz se llamará ArrayOfUser, lo cual no siempre encaja en integraciones.

6. Atributos para controlar la serialización

Con atributos puedes controlar el formato del XML: renombrar elementos, serializar como atributos, ignorar campos, etc. Atributos útiles: [XmlElement], [XmlAttribute], [XmlArray], [XmlIgnore].

Serializar como atributos

Guardemos nombre y apellido como atributos, y la edad como elemento:

public class User
{
    [XmlAttribute]
    public string FirstName { get; set; }

    [XmlAttribute]
    public string LastName { get; set; }

    [XmlElement]
    public int Age { get; set; }
}

Resultado:

<User FirstName="Iván" LastName="Petrov">
  <Age>30</Age>
</User>

Controlando los nombres de los elementos

Renombremos las etiquetas a algo más legible:

public class User
{
    [XmlElement("Nombre")]
    public string FirstName { get; set; }

    [XmlElement("Apellido")]
    public string LastName { get; set; }

    [XmlElement("Edad")]
    public int Age { get; set; }
}

XML resultante:

<User>
  <Nombre>Iván</Nombre>
  <Apellido>Petrov</Apellido>
  <Edad>30</Edad>
</User>

Ignorar propiedades

Si no quieres serializar una propiedad — márcala con [XmlIgnore]:

public class User
{
    public string FirstName { get; set; }

    [XmlIgnore]
    public string InternalCode { get; set; }
}

7. Serialización de jerarquías y objetos anidados

Las clases anidadas se convierten fácilmente en elementos XML anidados:

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

public class User
{
    public string FirstName { get; set; }
    public Address Address { get; set; }
}
var user = new User
{
    FirstName = "Ana",
    Address = new Address { City = "Neongrad", Street = "Vyazovaya" }
};

XmlSerializer serializer = new XmlSerializer(typeof(User));
using var fs = new FileStream("user_with_address.xml", FileMode.Create);
serializer.Serialize(fs, user);

XML:

<User>
  <FirstName>Ana</FirstName>
  <Address>
    <City>Neongrad</City>
    <Street>Vyazovaya</Street>
  </Address>
</User>

8. Serializar desde/a una cadena (sin archivos)

Serializar a una cadena

using System.Text;

var serializer = new XmlSerializer(typeof(User));
using var stringWriter = new StringWriter();

serializer.Serialize(stringWriter, user);
string xml = stringWriter.ToString();
Console.WriteLine(xml);

Deserializar desde una cadena

var xml = "<User><FirstName>Ana</FirstName></User>";
using var stringReader = new StringReader(xml);
User user = (User)serializer.Deserialize(stringReader);
Console.WriteLine(user.FirstName);

9. Ejemplo: exportar e importar datos de la aplicación

Exportar/importar la lista de usuarios a un archivo XML:

public static void ExportUsers(UserList users, string path)
{
    var serializer = new XmlSerializer(typeof(UserList));
    using var fs = new FileStream(path, FileMode.Create);
    serializer.Serialize(fs, users);
}

public static UserList ImportUsers(string path)
{
    var serializer = new XmlSerializer(typeof(UserList));
    using var fs = new FileStream(path, FileMode.Open);
    return (UserList)serializer.Deserialize(fs);
}

Uso: copias de seguridad, intercambio con otros servicios, integraciones. En entrevistas aparecen preguntas sobre XmlSerializer más a menudo de lo que parece — especialmente en empresas que trabajan con servicios estatales y bancos.

10. Errores típicos y particularidades

Si el campo no es public, no se serializa.

Las propiedades solo de lectura se ignoran.

Las propiedades cuyo tipo es una interfaz o una clase abstracta no son soportadas por el serializer.

El tipo DateTime se serializa en formato XSD (ver la documentación).

Las colecciones tipo arrays y List<T> funcionan de forma predecible, pero con ObservableCollection<T> pueden surgir sorpresas en sistemas externos.

Matices de codificación: si usas StreamWriter sin especificar encoding, el resultado puede quedar en UTF-16; para compatibilidad muchas veces se espera UTF-8 — especifica la codificación explícitamente.

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