1. Introducción
Ya que decidimos "desmontar la figurita LEGO en piezas", vamos a ver qué herramientas tenemos en .NET para eso. En otras palabras: qué clases estándar ayudan a serializar y deserializar objetos a distintos formatos y qué hay detrás de cada una.
Cómo está compuesto el ecosistema de serialización en .NET
En el momento actual (2025) .NET ofrece varios enfoques principales para la serialización, cada uno con su propio conjunto de clases e herramientas. Los principales y más comunes:
- JSON-serialización — la opción principal y más moderna, usada en la mayoría de proyectos.
- XML-serialización — un poco más anticuada, pero aún en uso activo.
- Serialización binaria — solo para casos especiales y normalmente vía soluciones de terceros modernas.
Muchos ejemplos y la mayor parte del código en .NET 9 usan precisamente JSON, y no es una moda — es un estándar de la industria. Pero .NET también soporta otras opciones, por si acaso.
Los protagonistas de la serialización en .NET
| Formato | Clase de serialización | Simplicidad | Rendimiento | Seguridad | Actualidad |
|---|---|---|---|---|---|
| JSON | |
🔥🔥🔥 | 🔥🔥🔥 | 🔥🔥🔥 | La más actual |
| XML | |
🔥🔥 | 🔥🔥 | 🔥🔥 | Se usa |
| JSON | Newtonsoft.Json (Json.NET) | 🔥🔥🔥 | 🔥🔥 | 🔥🔥🔥 | Muy popular |
Breve sobre cada uno
- System.Text.Json: El nuevo estándar para serializar JSON en .NET, apareció en .NET Core 3.0 y se convirtió en la opción principal en .NET 5+. Rápido, ligero, seguro e integrado "out of the box" en .NET 9. Documentación
- XmlSerializer: Opción antigua y probada para serializar a XML. Fácil de usar, pero con limitaciones (por ejemplo, necesita clase public y propiedades públicas). Bueno para compatibilidad y contratos de datos estrictos. Documentación
- Newtonsoft.Json: Durante mucho tiempo fue el estándar de facto para JSON antes de System.Text.Json. Se usa para escenarios complejos (dinámica, propiedades privadas, etc.). Documentación
¿Qué pasó con BinaryFormatter?
Si encuentras en Internet consejos de usar BinaryFormatter, probablemente sea un tutorial antiguo. No uses BinaryFormatter: fue eliminado en .NET 9 por razones de seguridad. La serialización binaria moderna se hace con soluciones de terceros — por ejemplo, Protobuf o MessagePack.
2. Ejemplos simples
Vamos a poner en práctica la serialización y deserialización con nuestro ya conocido clase Player del universo de juego.
Preparamos la clase para serializar
// Player.cs
public class Player
{
public string Name { get; set; }
public int Health { get; set; }
public bool IsAlive { get; set; }
public List<string> Inventory { get; set; }
public Position Position { get; set; }
}
public class Position
{
public int X { get; set; }
public int Y { get; set; }
}
a) Serialización y deserialización a JSON con System.Text.Json
using System.Text.Json;
Player aragorn = new Player
{
Name = "Aragorn",
Health = 100,
IsAlive = true,
Inventory = new List<string> { "sword", "bow", "healing potion" },
Position = new Position { X = 10, Y = 25 }
};
// Serializar el objeto Player a una cadena JSON
string json = JsonSerializer.Serialize(aragorn);
// Imprimimos el JSON por pantalla
Console.WriteLine(json);
// Deserializar la cadena JSON de vuelta a un objeto Player
Player? aragornClone = JsonSerializer.Deserialize<Player>(json);
// Comprobamos que el clon funciona :)
Console.WriteLine(aragornClone?.Name); // Debería imprimir "Aragorn"
Así de sencillo — nada de "rituales mágicos" ni atributos raros. Y ahora — cómo queda en XML.
b) Serialización y deserialización a XML con XmlSerializer
using System.Xml.Serialization;
// Configuramos el serializer para la clase Player
XmlSerializer serializer = new XmlSerializer(typeof(Player));
// Serialización a archivo
using FileStream fs = new FileStream("aragorn.xml", FileMode.Create);
serializer.Serialize(fs, aragorn); // Guardamos a Aragorn en un archivo XML
// Deserialización desde archivo
using FileStream fs = new FileStream("aragorn.xml", FileMode.Open);
Player aragornFromXml = (Player) serializer.Deserialize(fs)!;
Console.WriteLine(aragornFromXml.Name); // Debería imprimir "Aragorn"
¡Atención! XmlSerializer requiere que las clases y sus propiedades sean públicas y tengan un constructor sin parámetros por defecto (si sobrescribes el constructor — hazlo public y sin parámetros). Si no, la serialización fallará.
c) Serialización y deserialización a JSON con Newtonsoft.Json
using Newtonsoft.Json; // ¡No olvides añadir el paquete Newtonsoft.Json vía NuGet!
// Serialización
string json2 = JsonConvert.SerializeObject(aragorn);
// Deserialización
Player? aragornFromNewtonsoft = JsonConvert.DeserializeObject<Player>(json2);
Console.WriteLine(aragornFromNewtonsoft?.Name); // De nuevo "Aragorn"
Se ve casi igual, pero Newtonsoft.Json tiene muchas opciones extra — por ejemplo, puedes serializar campos privados, ajustar el formateo y resolver escenarios no triviales.
4. Matices útiles
Serializadores estándar y sus capacidades
| Clase | Formato | Integrado en .NET | ¿Requiere paquete NuGet? | Bueno para archivos | Bueno para API | Simplicidad |
|---|---|---|---|---|---|---|
|
JSON | Sí | No | Sí | Sí | Ligero |
|
JSON | No | Sí | Sí | Sí | Ligero |
|
XML | Sí | No | Sí | A menudo | Ligero |
¿Cómo decidir qué clase usar?
Si no sabes para qué necesitas XML — casi siempre elige JSON y System.Text.Json. Es más rápido, más simple y sigue las prácticas modernas.
XML conviene elegir si:
- Te integras con sistemas antiguos que requieren exactamente XML.
- Necesitas un esquema estricto y validación de la estructura de datos.
- Las estructuras son grandes, estables y la compatibilidad formal es importante (configuraciones, intercambio con sistemas enterprise).
JSON — si:
- Estás creando una app moderna, interactúas con web o dispositivos móviles.
- Necesitas simplicidad, legibilidad y compacidad.
- No quieres añadir dependencias extras.
Newtonsoft.Json — si:
- Necesitas serialización de campos privados, personalizaciones especiales, flexibilidad total.
- O el proyecto ya heredó esa librería y migrar no es práctico ahora mismo.
5. Errores típicos y trampas
Codificación. Las clases estándar de serialización (especialmente al trabajar con archivos) usan UTF-8 por defecto. Si ves "mojibake", revisa cómo lees/escribes archivos y la configuración explícita de la codificación. Documentación sobre la configuración de encoding.
Tipos no soportados. Algunos serializadores estándar (especialmente XML) no saben serializar, por ejemplo, diccionarios (Dictionary), campos privados/protected, eventos, delegates e interfaces. Normalmente se soportan propiedades públicas simples y clases.
Versiones de clases. Si cambias la estructura de tus clases (añades/renombras/eliminás propiedades), los datos guardados antes pueden no leerse o deserializarse mal. Planifica versionado de formatos.
Valores null. Al deserializar, si en los datos falta un campo, la propiedad correspondiente obtendrá el valor por defecto (para tipos referencia — null). No olvides comprobarlo.
Atributos. Para ajustes finos se usan atributos como [JsonIgnore], [XmlElement], etc. Permiten excluir propiedades, cambiar nombres de elementos y controlar el formato — lo veremos con más detalle en próximas lecciones.
GO TO FULL VERSION