CodeGym /Cursos /C# SELF /Trabajar con objetos anidados y colecciones

Trabajar con objetos anidados y colecciones

C# SELF
Nivel 45, Lección 1
Disponible

1. Introducción

La serialización de objetos sencillos es como enviar una postal por correo: todo es simple, no se pierde nada. Pero muchas veces nuestros objetos se convierten en "álbumes familiares": contienen objetos anidados, colecciones e incluso colecciones de colecciones.

Imagina que nuestro usuario no es solo un Person con nombre y edad, sino que, por ejemplo, tiene un conjunto de contactos (Contact), varias direcciones de casa/trabajo, y quizá un campo de tipo List<Pet> si le gustan los animales. Todo esto son objetos anidados y colecciones.

¿Cómo se las arreglan los serializadores de .NET con esto? ¿Qué matices hay que tener en cuenta cuando serializamos árboles complejos de objetos? ¿Puede romperse todo si dentro de las colecciones hay otras colecciones? Hoy veremos qué esperar — y qué hacer en casos complejos.

Qué significa "anidamiento" en términos de .NET

Un objeto anidado es simplemente otro objeto como propiedad o campo dentro de tu objeto principal. Por ejemplo, este es nuestro modelo de usuario extendido:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<Contact> Contacts { get; set; }         // Colección de objetos anidados
    public Address? HomeAddress { get; set; }           // Un objeto anidado (nullable)
}
public class Contact
{
    public string Type { get; set; }                    // Por ejemplo, Email o Phone
    public string Value { get; set; }
}
public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

Fíjate — una persona puede tener varios contactos, y la dirección solo una (y puede ser null). Esto es clásico en muchos modelos.

2. Serializar objetos y colecciones con System.Text.Json

Ejemplo simple: serializamos y deserializamos una colección

Veamos cómo funciona en la práctica:

using System.Text.Json;

var person = new Person
{
    Name = "Anna",
    Age = 28,
    Contacts = new List<Contact>
    {
        new Contact { Type = "Email", Value = "anna@example.com" },
        new Contact { Type = "Phone", Value = "+1234567890" }
    },
    HomeAddress = new Address { City = "Berlín", Street = "Alexanderplatz, 1" }
};

string json = JsonSerializer.Serialize(person, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

El resultado será más o menos así:

{
  "Name": "Anna",
  "Age": 28,
  "Contacts": [
    {
      "Type": "Email",
      "Value": "anna@example.com"
    },
    {
      "Type": "Phone",
      "Value": "+1234567890"
    }
  ],
  "HomeAddress": {
    "City": "Berlín",
    "Street": "Alexanderplatz, 1"
  }
}

El serializador entiende perfectamente el anidamiento. Si una propiedad es otro objeto, lo serializa "anidado". Si es una lista, la serializa como un array.

Dato: Esa serialización funciona automáticamente para cualquier colección y objeto anidado si son públicos y tienen getter y setter públicos (get/set).

Deserialización: funciona "out of the box"

string jsonInput = /* JSON que acabamos de obtener */;
Person deserializedPerson = JsonSerializer.Deserialize<Person>(jsonInput);
Console.WriteLine(deserializedPerson.Name); // "Anna"
Console.WriteLine(deserializedPerson.Contacts[0].Type); // "Email"

Todo funciona — los contactos se convierten del array JSON de vuelta a List<Contact>, HomeAddress vuelve a ser un objeto de la clase Address.

3. Cómo se serializan las colecciones: List, arrays, Dictionary

A menudo dentro de tu modelo no solo hay listas (List<T>), sino diccionarios (Dictionary<TKey, TValue>) o arrays multidimensionales.

Ejemplo con array

public class Team
{
    public string Name { get; set; }
    public Person[] Members { get; set; }
}

var team = new Team
{
    Name = "Desarrolladores",
    Members = new[]
    {
        new Person { Name = "Alex", Age = 31 },
        new Person { Name = "Kate", Age = 27 }
    }
};
string json = JsonSerializer.Serialize(team, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

JSON:

{
  "Name": "Desarrolladores",
  "Members": [
    {
      "Name": "Alex",
      "Age": 31,
      "Contacts": null,
      "HomeAddress": null
    },
    {
      "Name": "Kate",
      "Age": 27,
      "Contacts": null,
      "HomeAddress": null
    }
  ]
}

La serialización de una colección se parece a empaquetar un montón de postales idénticas: cada elemento es una "postal" separada.

Ejemplo con Dictionary

public class Phonebook
{
    public Dictionary<string, string> Phones { get; set; }
}

var phonebook = new Phonebook
{
    Phones = new Dictionary<string, string>
    {
        { "Andrew", "+12998887766" },
        { "Maria", "+12882223344" }
    }
};

string json = JsonSerializer.Serialize(phonebook, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

JSON:

{
  "Phones": {
    "Andrew": "+12998887766",
    "Maria": "+12882223344"
  }
}

En JSON, un diccionario se convierte en un objeto con claves dinámicas.

4. Colecciones anidadas (List dentro de List, arrays de arrays)

.NET sabe serializar también estas "matrioshkas":

public class Zoo
{
    public List<List<Animal>> AnimalGroups { get; set; }
}
public class Animal { public string Name { get; set; } }

var zoo = new Zoo
{
    AnimalGroups = new List<List<Animal>>
    {
        new List<Animal> { new Animal { Name = "León" }, new Animal { Name = "Tigre" } },
        new List<Animal> { new Animal { Name = "Oso" } }
    }
};

string json = JsonSerializer.Serialize(zoo, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

JSON:

{
  "AnimalGroups": [
    [ { "Name": "León" }, { "Name": "Tigre" } ],
    [ { "Name": "Oso" } ]
  ]
}

Lo mismo aplica en la deserialización de vuelta.

5. Particularidades de serializar objetos anidados con XmlSerializer

Ejemplo de serialización de un objeto anidado

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

var person = new Person
{
    Name = "John",
    Age = 35,
    HomeAddress = new Address { City = "Bonn", Street = "Beethoven str., 100" },
    Contacts = new List<Contact>
    {
        new Contact { Type = "Email", Value = "ivan@domain.de" }
    }
};

var serializer = new XmlSerializer(typeof(Person));
using var writer = new StringWriter();
serializer.Serialize(writer, person);
Console.WriteLine(writer.ToString());

Resultado:

<?xml version="1.0" encoding="utf-16"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>John</Name>
  <Age>35</Age>
  <Contacts>
    <Contact>
      <Type>Email</Type>
      <Value>ivan@domain.de</Value>
    </Contact>
  </Contacts>
  <HomeAddress>
    <City>Bonn</City>
    <Street>Beethoven str., 100</Street>
  </HomeAddress>
</Person>

Particularidades de las colecciones en XmlSerializer

Por defecto XmlSerializer serializa una colección como la etiqueta "Contacts", dentro de la cual para cada elemento se crea una etiqueta "Contact". Para esto, el tipo de colección debe ser público y sus elementos tipos serializables.

Punto importante. Si la colección está vacía, el XML igualmente incluye la etiqueta vacía:

<Contacts />

Colecciones soportadas. XmlSerializer soporta List<T>, arrays T[], colecciones que implementen ICollection<T>. No soporta, por ejemplo, Dictionary<TKey, TValue>! Para serializar diccionarios habrá que usar técnicas adicionales o librerías externas.

6. Soporte de objetos y colecciones en Newtonsoft.Json

Newtonsoft.Json soporta el anidamiento de forma un poco más flexible. En el 99% de los casos todo funciona igual que en System.Text.Json, pero tiene ventajas: puedes serializar incluso campos privados (si lo especificas), diccionarios con claves más complejas, tipos dinámicos, e incluso referencias cíclicas (con configuraciones especiales).

Ejemplo

using Newtonsoft.Json;

var person = new Person
{
    Name = "Paul",
    Age = 40,
    Contacts = new List<Contact>
    {
        new Contact { Type = "SMS", Value = "+10000000013" }
    }
};
string json = JsonConvert.SerializeObject(person, Formatting.Indented);
Console.WriteLine(json);

Diferencia. Si un objeto tiene, por ejemplo, campos privados, se pueden serializar con la configuración de ContractResolver. Pero para colecciones y objetos anidados básicos todo funciona automáticamente "out of the box".

7. Errores típicos, trampas y matices

Error 1: Objetos anidados — null.
Si en el objeto que serializas algunas propiedades no están establecidas (null), en JSON o XML pueden no aparecer en absoluto, o pueden registrarse como null. Por ejemplo, si HomeAddress de Person es null, en JSON:

"HomeAddress": null

En XML por defecto esa etiqueta no existirá — se puede añadir con la configuración del serializador ([XmlElement(IsNullable=true)]).

Error 2: Serializar propiedades/campos privados.
Por defecto la mayoría de los serializadores (JSON y XML) trabajan solo con propiedades públicas. Si quieres serializar campos privados o protegidos, tendrás que hacerlos públicos o configurar el serializador (por ejemplo, mediante ContractResolver en Newtonsoft.Json).

Error 3: Clases sin constructor por defecto.
En la serialización XML (y a menudo en JSON) la clase debe tener un constructor público sin parámetros. Si no lo tiene — habrá una excepción al deserializar.

Error 4: Serializar diccionarios en XML.
XmlSerializer no soporta de inmediato la serialización de Dictionary<TKey, TValue>. Esto suele ser una sorpresa. La solución puede ser envolver el diccionario en una lista de pares o usar otros serializadores.

Error 5: Referencias cíclicas.
Si un objeto contiene por referencia a otro objeto que a su vez referencia de nuevo al primero (por ejemplo, padre y niño), la serialización "en bucle" puede causar un desbordamiento de pila (StackOverflowException) o una excepción de referencia cíclica. En los serializadores JSON esto puede evitarse con configuraciones, pero muchas veces es mejor replantear la arquitectura del objeto.

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