CodeGym /Cursos /C# SELF /Ejemplos básicos de serialización

Ejemplos básicos de serialización

C# SELF
Nivel 45, Lección 0
Disponible

1. Introducción

Recordatorio: La serialización es una forma de guardar el estado de un objeto en forma de cadena, archivo o flujo, para que más tarde puedas restaurar ese objeto (deserializarlo) — y volver a tener un objeto con los mismos datos.

Situación típica:
1) Tienes un objeto, por ejemplo, un usuario con nombre y edad.
2) Necesitas guardarlo — enviarlo por la red, escribirlo en un archivo o, por ejemplo, en formato JSON.
3) Luego sacas los datos de la cadena/archivo — ¡y recuperas el objeto!

En C# se hace literalmente en un par de líneas. Vamos a ver cómo.

Nuestra aplicación

Estamos desarrollando una pequeña aplicación «Gestor de contactos». Supongamos que tenemos la clase Person, que queremos serializar.

public class Person
{
    // ¡Las propiedades públicas son necesarias para la serialización!
    public string Name { get; set; }
    public int Age { get; set; }

    // El constructor sin parámetros es obligatorio para XmlSerializer
    public Person() { }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Si no conoces esta sintaxis, no te preocupes — más adelante en el curso veremos clases y propiedades en detalle. Ahora considéralo como un modelo de datos para experimentar. Fíjate: las propiedades públicas Name y Age — son importantes para la serialización, y para XmlSerializer se necesita un constructor público sin parámetros.

2. Serialización a JSON con System.Text.Json

Ejemplo básico

Lo prometido es deuda — ¡aquí va! Así se ve la serialización a JSON:

using System;
using System.Text.Json;

Person person = new Person("Alicia", 28);

// Serialización: convertimos el objeto a una cadena JSON
string json = JsonSerializer.Serialize(person);

Console.WriteLine("JSON:");
Console.WriteLine(json);

¿Qué aparecerá en pantalla?

JSON:
{"Name":"Alicia","Age":28}

Fácil: objeto → JSON. ¡Ahí está la magia!

Deserialización — devolvemos todo atrás

Ahora hacemos la operación inversa — desde una cadena JSON recuperamos el objeto:

string json = "{\"Name\":\"Bob\",\"Age\":35}";

// Deserialización: restauramos un objeto de tipo Person desde la cadena JSON
Person restored = JsonSerializer.Deserialize<Person>(json);

Console.WriteLine("Objeto restaurado:");
Console.WriteLine($"Nombre: {restored.Name}, edad: {restored.Age}");

Resultado:

Objeto restaurado:
Nombre: Bob, edad: 35

Fíjate: si la estructura de datos no coincide (por ejemplo, falta una propiedad), el campo correspondiente permanecerá con el valor por defecto (null para tipos referencia, 0 para números, etc.).

3. Serialización/deserialización a XML con XmlSerializer

Serialización a XML — primera mirada

using System;
using System.IO;
using System.Xml.Serialization;

Person person = new Person("Kate", 22);

// Creamos el XmlSerializer para el tipo Person
var serializer = new XmlSerializer(typeof(Person));

// Escribimos el XML en un archivo
using (var stream = new FileStream("person.xml", FileMode.Create))
{
    serializer.Serialize(stream, person);
    // El stream se cerrará automáticamente al final del bloque using
}
Console.WriteLine("¡Archivo XML creado!");

En el archivo person.xml aparecerá algo como esto:

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Kate</Name>
  <Age>22</Age>
</Person>

Punto importante:
Para serializar en un archivo se usa un flujo (Stream, por ejemplo, FileStream). Si quieres serializar a una cadena (por ejemplo, para enviar por la red), usa StringWriter:

var serializer = new XmlSerializer(typeof(Person));
using (var sw = new StringWriter())
{
    serializer.Serialize(sw, person);
    string xmlString = sw.ToString();
    Console.WriteLine(xmlString);
}

Deserialización desde XML

using (var stream = new FileStream("person.xml", FileMode.Open))
{
    // ¡No olvides castear al tipo correcto!
    Person restored = (Person)serializer.Deserialize(stream);
    Console.WriteLine($"Nombre: {restored.Name}, edad: {restored.Age}");
}

Otra vez: XmlSerializer requiere que la clase a serializar tenga un constructor público por defecto (sin parámetros).

4. Trabajar con archivos y cadenas: ¿qué elegir?

En la vida real la serialización puede ir directamente a una cadena (para envío por red/almacenamiento en BD) o a un archivo (para almacenamiento a largo plazo).

Serializar a cadena (por ejemplo, para pasar por un API):

  • JSON: usamos JsonSerializer.Serialize(obj).
  • XML: a través de StringWriter.

Serializar a archivo (por ejemplo, para exportar/backup):

  • JSON: guardamos la cadena en un archivo con las funciones habituales de I/O.
  • XML: escribimos directamente en el stream con XmlSerializer.

Ejemplo: serializar a archivo y volver (JSON)

using System.IO;
using System.Text.Json;

Person person = new Person("Tom", 42);

// Serialización a cadena
string json = JsonSerializer.Serialize(person);

// Escribir en archivo
File.WriteAllText("contact.json", json);

// Leer desde archivo
string readJson = File.ReadAllText("contact.json");
Person restored = JsonSerializer.Deserialize<Person>(readJson);

Console.WriteLine($"{restored.Name}, edad: {restored.Age}");

5. Comparación JSON vs XML

Visualización del proceso

Para no liarnos, aquí tienes el esquema del proceso de serialización y deserialización:

flowchart LR
    A[Objeto] -- serialización --> B[Cadena/Archivo/Flujo]
    B -- deserialización --> C[Objeto]

    A -. JSON o XML .-> B
    B -. JSON o XML .-> C

Puedes imaginar que la serialización es "hacer la maleta" y la deserialización es "deshacerla" en casa.

Tabla comparativa

Funcionalidad JSON (System.Text.Json) XML (XmlSerializer)
Lectura/escritura en cadena ++ +
Lectura/escritura en archivo ++ ++
Requiere constructor sin parámetros No Sí
Legibilidad para humanos ++ +
Esquema estricto de datos (validación) - ++
Flexibilidad (atributos de personalización) + ++
Rendimiento ++ +
Compatibilidad con internet ++ +

++ — muy bien, + — normal, - — no soportado

6. Cómo añadir serialización a nuestra aplicación

Supongamos que en el "Gestor de contactos" apareció la opción de guardar la lista de contactos en un archivo y recuperarla.

Contexto: tenemos una lista de contactos (List<Person>).

List<Person> contacts = new List<Person>
{
    new Person("Basil", 30),
    new Person("Peter", 25),
    new Person("Mary", 27)
};

// Guardamos todos los contactos — serializamos a JSON
string jsonContacts = JsonSerializer.Serialize(contacts);
File.WriteAllText("contacts.json", jsonContacts);

// Restauramos la lista de contactos
string readContactsJson = File.ReadAllText("contacts.json");
List<Person> restored = JsonSerializer.Deserialize<List<Person>>(readContactsJson);

foreach (var c in restored)
{
    Console.WriteLine($"{c.Name}, edad: {c.Age}");
}

Lo mismo se puede hacer con XML, pero tiene sus particularidades. Para serializar colecciones con XmlSerializer normalmente envuelves la lista en una clase contenedora (elemento raíz) — así es más fácil controlar el formato y los nombres de los elementos.

7. Errores típicos al serializar y deserializar

Error nº1: desajuste de tipos al serializar y deserializar.
Si serializaste List<Person> — debes deserializar también en List<Person>, no en List<object> o IEnumerable<Person>. Si no, obtendrás un error o resultados inesperados.

Error nº2: intentar serializar campos y propiedades no públicos.
Los serializadores típicos (JsonSerializer, XmlSerializer) trabajan con miembros públicos. Si una propiedad no tiene getter/setter público, su valor puede no aparecer en el JSON/XML, y te preguntarás por qué está null.

Error nº3: ausencia de constructor sin parámetros.
Para XmlSerializer el constructor público por defecto es obligatorio. Si no existe — habrá una excepción al deserializar.

Error nº4: mal entendimiento de las referencias entre objetos.
Si un objeto contiene referencia a otro, la serialización va "por valor" (como objeto anidado). Las referencias como tal no se guardan, lo que puede causar duplicación de datos o problemas con referencias cíclicas.

Error nº5: intentar mezclar formatos de serialización.
XML y JSON son formatos distintos y usan serializadores distintos. No puedes pasar una cadena JSON a XmlSerializer y viceversa — dará error.

2
Tarea
C# SELF, nivel 45, lección 0
Bloqueada
Serialización y deserialización de un objeto en JSON
Serialización y deserialización de un objeto en JSON
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION