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.
GO TO FULL VERSION