CodeGym /Cursos /C# SELF /Serialización de colecciones simples: List<T>, T[]

Serialización de colecciones simples: List<T>, T[]

C# SELF
Nivel 46, Lección 0
Disponible

1. Introducción

Ya hemos trabajado antes con colecciones. Sin ellas no vas a ninguna parte ni en programación ni en la vida. Imagina que haces una lista de tareas para el día: comprar comida, llamar al médico, recoger un pedido. Difícilmente vas a crear un cuaderno distinto para cada tarea. Es mucho más fácil y lógico apuntar todo en una sola lista.

Lo mismo en programación: cuando hay muchos objetos — usuarios, pedidos, mensajes — no creamos una variable por cada uno. En su lugar usamos colecciones: listas, diccionarios, sets. Eso permite almacenar, iterar y procesar grupos de datos de forma cómoda.

Escenarios de la vida real:

  • Almacenamiento e intercambio de datos entre aplicaciones: tu colección de libros puede moverse de un programa a otro.
  • Cachear conjuntos de datos en disco.
  • Transferencia de datos por la red (frontend ↔ backend).
  • Import/export de información (por ejemplo, decides hacer tu propio export de libros a JSON).

En una entrevista: «¿Cómo serializarías y guardarías una lista de pedidos?» — quedará muy bien si mencionas no solo un objeto sino también la serialización de colecciones.

2. Cómo funcionan las colecciones al serializar

JSON y colecciones: una breve historia de amor

Cuando serializas un objeto normal, se convierte en un objeto JSON del tipo { "field": value }. Pero si serializas una lista o un array, obtendrás un array JSON [ ... ].

Visualmente:

C# JSON
List<int> { 1, 2, 3 }
[1, 2, 3]
Book[]
[{"Title":"A","Author":"B"}, ...]
List<Book>
[{"Title":"A"}, {"Title":"B"}]

La magia principal: Llamas a JsonSerializer.Serialize() sobre la colección — ¡y se convierte automáticamente en un array! En la dirección contraria Deserialize<List<T>>() — y la magia vuelve a ocurrir.

Correspondencia entre colecciones de C# y arrays JSON

Tipo de colección en C# Ejemplo JSON
Book[]
new Book[] { ... }
[ { ... }, { ... } ]
List<Book>
new List<Book> { ... }
[ { ... }, { ... } ]
int[]
new int[] { 1, 2, 3 }
[1, 2, 3]
List<string>
new List<string> { "a", "b" }
["a", "b"]
List<List<Book>>
new List<List<Book>> { ... }
[ [ { ... } ], [ { ... } ] ]

3. Ejemplo: serialización y deserialización de un array de libros

Empecemos con un ejemplo mínimo. Tomemos nuestra clase Book, que ya vimos en lecciones anteriores:

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
}

Ahora creamos un array de libros, lo serializamos, lo guardamos en un archivo y lo cargamos de vuelta.

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

namespace LibraryApp
{
    public class Book
    {
        public string Title { get; set; }
        public string Author { get; set; }
    }

    class Program
    {
        static void Main()
        {
            // Creemos un array de libros
            Book[] books = new Book[]
            {
                new Book { Title = "Three Comrades", Author = "Erich Maria Remarque" },
                new Book { Title = "The Master and Margarita", Author = "Mikhail Bulgakov" },
                new Book { Title = "1984", Author = "George Orwell" }
            };

            // Serialización del array de libros a string
            var options = new JsonSerializerOptions { WriteIndented = true };	
            string json = JsonSerializer.Serialize(books, options);
            Console.WriteLine("JSON del array de libros:\n" + json);

            // Escribir en archivo (sincrónico)
            File.WriteAllText("books.json", json);

            // Leer del archivo (sincrónico)
            string jsonFromFile = File.ReadAllText("books.json");

            // Deserializar de vuelta al array
            Book[]? booksFromFile = JsonSerializer.Deserialize<Book[]>(jsonFromFile);

            // Mostramos el resultado en la consola
            Console.WriteLine("\nLibros deserializados:");
            if (booksFromFile != null)
            {
                foreach (var book in booksFromFile)
                {
                    Console.WriteLine($"- {book.Title} (autor: {book.Author})");
                }
            }
        }
    }
}

¿Qué pasa aquí?

  • Creas un array Book[] y lo llenas con tres libros.
  • Con JsonSerializer.Serialize conviertes el array en una cadena JSON legible (la opción WriteIndented hace el formato bonito).
  • La guardas en un archivo, la lees y la deserializas — ¡y vuelves a tener tu array de libros!
  • Compruebas que todos los datos se restauraron correctamente.

Comprueba que el archivo "books.json" aparece en la carpeta del programa. Ábrelo, y verás un JSON parecido a este:

[
  {
    "Title": "Three Comrades",
    "Author": "Erich Maria Remarque"
  },
  {
    "Title": "The Master and Margarita",
    "Author": "Mikhail Bulgakov"
  },
  {
    "Title": "1984",
    "Author": "George Orwell"
  }
]

4. Ejemplo: serialización de la colección List<T>

Trabajar con List<Book> no es diferente. El serializador detecta la colección y la convierte en un array JSON.

List<Book> myBooks = new List<Book>
{
    new Book { Title = "Crime and Punishment", Author = "Fyodor Dostoevsky" },
    new Book { Title = "War and Peace", Author = "Leo Tolstoy" }
};

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

// Y deserializamos así:
List<Book>? loadedBooks = JsonSerializer.Deserialize<List<Book>>(jsonList);

// ¡Comprobamos que todo volvió!
foreach (var book in loadedBooks!)
{
    Console.WriteLine($"{book.Title} ({book.Author})");
}

¿Se puede serializar una lista de enteros simple?

¡Por supuesto! La serialización funciona tanto para tus clases como para tipos simples:

List<int> numbers = new List<int> { 10, 20, 30, 40 };
string jsonNums = JsonSerializer.Serialize(numbers); // resultado: [10,20,30,40]
List<int>? loadedNums = JsonSerializer.Deserialize<List<int>>(jsonNums);
// loadedNums: List<int> con los mismos valores

5. Esquema y analogías: ¿cómo ve el serializador las colecciones?

Para entender mejor cómo funciona la serialización de colecciones, mira este esquema sencillo:

graph TD;
    A[List[Book] en C#] -->|Serialize| B[Array JSON en string]
    B -->|Write| C[Archivo books.json]
    C -->|Read| D[Cadena JSON desde archivo]
    D -->|Deserialize| E[List[Book] en C#]

Resumiendo el proceso:

  • La colección o el array se serializa como un array en JSON ([ ... ]).
  • El orden de los elementos se mantiene (a menos que uses opciones específicas).
  • Cada elemento de la colección se serializa como su propio objeto.

6. Particularidades de la serialización de colecciones: en qué fijarse

1. null y colecciones vacías

Si la colección es null, el serializador por defecto escribirá simplemente null en el JSON. Atención si en tu lógica de negocio una colección vacía y null no son lo mismo.

Si la colección está vacía (new List<Book>()), el JSON será [] — un array vacío. Es útil cuando quieres indicar explícitamente que no hay elementos.

2. Deserialización — el orden importa

El orden de los elementos en el array siempre se conserva. Si serializaste tres libros en ese orden, se restaurarán en el mismo orden.

3. ¿Colección con objetos de distintos tipos?

System.Text.Json no soporta polimorfismo «out of the box». Es decir, si tienes por ejemplo una List<Animal> con perros y gatos (cada uno es una clase derivada), por defecto no puedes restaurar «qué tipo exacto» era cada elemento. Llegaremos a la serialización polimórfica más adelante; con listas normales todo es sencillo.

7. Errores típicos y malentendidos comunes

Error №1: Serializamos la colección, pero olvidamos que puede contener objetos con campos privados

JsonSerializer serializa solo propiedades públicas (y con getters/setters). Si tu clase es así:

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

    private string Password { get; set; }  // ¡No se serializará!
}

La contraseña no aparecerá en el JSON, y eso suele ser bueno por seguridad. Pero si querías guardarla, recuerda hacer la propiedad pública.

Error №2: Serialización de colecciones con elementos null

Si la colección contiene null, por ejemplo: new List<Book> { null, book2 }, después de serializar el primer elemento será null. Al deserializar — igual. Ejemplo de JSON así:

[null, { "Title": "War and Peace", "Author": "Leo Tolstoy" }]

En la práctica esto pasa raramente, pero si serializas una colección con "huecos", tenlo en cuenta en la lógica.

Error №3: Tipo incorrecto al deserializar

Error común: serializaste una lista y deserializas a un array (o viceversa). Funciona si los tipos son compatibles (Book[] ↔ List<Book>), pero pueden surgir matices si intentas deserializar un array de strings a un objeto que no corresponde.

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