CodeGym /Cursos /C# SELF /Serialización de diccionarios

Serialización de diccionarios

C# SELF
Nivel 46, Lección 1
Disponible

1. Introducción

Un diccionario (o Dictionary<TKey, TValue> en C#) es una colección de pares "clave-valor". Este tipo de dato es irremplazable cuando necesitas encontrar rápidamente un valor por un identificador único (por ejemplo, buscar un teléfono por nombre en una agenda).

A diferencia de las listas (List<T>), donde el orden importa, el diccionario se centra en el acceso rápido por clave. Pero si al serializar una lista todo es sencillo (un array JSON), al serializar un diccionario aparecen varias sutilezas:

  • La clave debe ser un tipo serializable (habitualmente una cadena, pero a veces puede ser un número o incluso otro objeto).
  • En JSON no hay "diccionarios" separados: solo objetos o arrays.

Vamos a ver con más detalle cómo .NET serializa los diccionarios, qué dificultades pueden aparecer y cómo "enseñar" a nuestro código a manejar estas estructuras.

2. Serialización de un diccionario con claves cadena

Empecemos por lo clásico: un diccionario donde tanto la clave como el valor son cadenas.


// Ejemplo de diccionario: libro y su autor
var books = new Dictionary<string, string>
{
    ["Master and Margarita"] = "Mikhail Bulgakov",
    ["Harry Potter"] = "Joan Rowling",
    ["Lord of the Flies"] = "William Golding"
};

// Serialización a cadena JSON
string json = JsonSerializer.Serialize(books, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine("El diccionario se serializó a JSON:\n" + json);

// Guardamos en un archivo (síncrono)
File.WriteAllText("books.json", json);
Console.WriteLine("JSON escrito en el archivo books.json.");

// Leemos de vuelta desde el archivo (síncrono)
string jsonFromFile = File.ReadAllText("books.json");

// Deserialización de vuelta al diccionario
var restoredBooks = JsonSerializer.Deserialize<Dictionary<string, string>>(jsonFromFile);
Console.WriteLine("Resultado de la deserialización:");
foreach (var pair in restoredBooks)
    Console.WriteLine($"{pair.Key} -> {pair.Value}");

¿Qué habrá en el archivo books.json?

{
  "Master and Margarita": "Mikhail Bulgakov",
  "Harry Potter": "Joan Rowling",
  "War and Peace": "William Golding"
}

¿Cómo funciona?

El serializador convierte nuestro Dictionary<string, string> en un objeto JSON donde cada clave se convierte en el nombre de una propiedad y el valor en el valor de esa propiedad. Es cómodo cuando las claves son cadenas y son únicas.

3. Diccionario con tipo de clave no estándar

Todo es sencillo mientras la clave sea una cadena. ¿Y si fuera, por ejemplo, un número?


var bookIds = new Dictionary<int, string>
{
    [1001] = "Master and Margarita",
    [1002] = "Harry Potter",
    [1003] = "Lord of the Flies"
};

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

Resultado:

{
  "1001": "Master and Margarita",
  "1002": "Harry Potter",
  "1003": "Lord of the Flies"
}

¿Qué pasó?

  • C# convirtió las claves numéricas en cadenas, porque en JSON los nombres de las propiedades solo pueden ser cadenas.
  • Al deserializar de vuelta a Dictionary<int, string> el serializador intentará convertir la cadena de nuevo a número.

Ejemplo de deserialización:


var restoredBookIds = JsonSerializer.Deserialize<Dictionary<int, string>>(jsonIntKeys);
// ¡Todo funciona! Las claves vuelven a ser números.
¿Y si la clave es un tipo complejo, por ejemplo, un objeto?

var dict = new Dictionary<Author, string>
{
    [new Author { Name = "Golding", BirthYear = 1911 }] = "Lord of the Flies"
};

Intentar serializar ese diccionario provocará una excepción:

System.NotSupportedException: Serialization and deserialization of 'Dictionary<Author, string>' instances are not supported.

¿Por qué?

Un objeto JSON no puede usar otra cosa que no sea una cadena como nombre de propiedad. Por eso, al serializar, las claves del diccionario deben ser tipos sencillos que se puedan convertir de forma unívoca a cadena (habitualmente string o número). No se pueden usar objetos complejos como claves al serializar a JSON con las herramientas estándar.

4. Diccionario con objetos anidados como valor

Las claves ya están claras — ahora veamos qué pasa si el valor es un objeto complejo (por ejemplo, Book o Author).

Ejemplo


public class Author
{
    public string Name { get; set; }
    public int BirthYear { get; set; }
}

var authorDirectory = new Dictionary<string, Author>
{
    ["bulgakov"] = new Author { Name = "Mikhail Bulgakov", BirthYear = 1891 },
    ["golding"] = new Author { Name = "William Golding", BirthYear = 1911 }
};

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

Resultado:

{
  "bulgakov": {
    "Name": "Mikhail Bulgakov",
    "BirthYear": 1891
  },
  "golding": {
    "Name": "William Golding",
    "BirthYear": 1911
  }
}
  • Todo lo anidado se serializa según la estructura de los objetos.
  • La deserialización de vuelta a Dictionary<string, Author> también funciona sin problemas.

5. Diccionario dentro de otro objeto

Muy a menudo los diccionarios se usan como un campo dentro de un objeto más complejo. Por ejemplo, una biblioteca que tiene un catálogo donde cada clave es el nombre del género y el valor es la lista de libros de ese género.


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

public class Library
{
    public Dictionary<string, List<Book>> CatalogByGenre { get; set; }
}

var library = new Library
{
    CatalogByGenre = new Dictionary<string, List<Book>>
    {
        ["Science Fiction"] = new List<Book>
        {
            new Book { Title = "Solaris", Author = "Stanislaw Lem" }
        },
        ["Classics"] = new List<Book>
        {
            new Book { Title = "Lord of the Flies", Author = "William Golding" },
            new Book { Title = "Darkness Visible", Author = "William Golding" }
        }
    }
};

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

Fragmento del JSON resultante:

{
  "CatalogByGenre": {
    "Science Fiction": [
      {
        "Title": "Solaris",
        "Author": "Stanislaw Lem"
      }
    ],
    "Classics": [
      {
        "Title": "Lord of the Flies",
        "Author": "William Golding"
      },
      {
        "Title": "Darkness Visible",
        "Author": "William Golding"
      }
    ]
  }
}

Funciona: los diccionarios y colecciones anidadas se serializan y deserializan de forma recursiva.

6. Particularidades y "piedras en el camino" de la serialización de diccionarios

Claves duplicadas

En un diccionario las claves siempre son únicas. Pero si intentas meter a mano un JSON con claves duplicadas:

{
  "foo": "first",
  "foo": "second"
}

Resultado: el último valor ("second") sobrescribirá al primero; no habrá error. Así funcionan la mayoría de los parsers JSON.

Orden de los elementos

El diccionario es una colección no ordenada. Al serializar, el orden de las claves en el JSON puede diferir del original. Si el orden es crítico, usa una lista de pares (List<KeyValuePair<string, T>>), aunque normalmente en un diccionario el orden no importa.

JSON y diccionarios anidados

Los niveles de anidamiento no están limitados, pero para que todo funcione cada nivel debe respetar las reglas de JSON (claves — cadenas, valores — objetos o arrays JSON válidos).

Uso de JsonSerializerOptions

A veces necesitas que los nombres de las propiedades no estén en PascalCase sino en camelCase. Esto es importante si te integras con frontend en JavaScript, donde camelCase suele ser la convención.


var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    WriteIndented = true
};

string camelJson = JsonSerializer.Serialize(authorDirectory, options);

Importante: en los diccionarios esta opción afecta solo a la serialización de los objetos anidados (sus propiedades), pero no a las claves del diccionario. Las claves siempre se serializan tal cual se especificaron en C#.

7. Problemas con claves complejas y no-strings

La serialización funciona "out of the box" con claves string y claves numéricas (por ejemplo, int, long, Guid). Pero si intentas usar una clase o struct personalizada como clave obtendrás una NotSupportedException.

Para serializar esos casos hay soluciones alternativas:

  • Usar otro formato de almacenamiento: por ejemplo, serializar el diccionario como un array de objetos con campos "Key" y "Value".
  • Escribir un convertidor (JsonConverter) que convierta tu clave compleja a cadena y de vuelta.
  • Si la estructura es realmente compleja, quizá sea mejor replantear la arquitectura y no usar objetos complejos como claves del diccionario.

Ejemplo de workaround serializando como lista de pares


public class AuthorInfo
{
    public Author Author { get; set; }
    public string Book { get; set; }
}
// en vez de Dictionary<Author, string>
var list = new List<AuthorInfo>
{
    new AuthorInfo { Author = new Author { Name = "William Golding", BirthYear = 1911 }, Book = "Lord of the Flies" }
};
// esa lista se serializa sin problemas

Comparación: diccionario vs lista de pares al serializar

Tipo de colección Estructura JSON Cuándo usar
Dictionary<string, Book>
{ "key1": {...}, "key2": {...} }
Claves simples string, necesitas búsquedas rápidas y unicidad
List<KeyValuePair<string, Book>>
[{"Key": "key1", "Value": {...}}, ... ]
La clave es un tipo complejo, necesitas control del orden, permiten duplicados

8. Preguntas típicas en entrevistas

1. ¿Se puede serializar Dictionary<DateTime, string>?
Sí, pero las claves se convierten a su representación de cadena (normalmente un formato ISO tipo "yyyy-MM-ddTHH:mm:ss"). A veces en la deserialización pueden aparecer problemas por locales y formatos de fecha.

2. ¿Qué pasa si serializas Dictionary<int, string>?
Las claves se serializan como cadenas, aunque en el diccionario original fueran números. Al deserializar normalmente se convierten de vuelta correctamente.

3. ¿Por qué no se puede serializar un diccionario con objetos como clave?
Porque solo las cadenas pueden ser nombres de propiedades en un objeto JSON; los objetos no.

4. ¿Y si quiero serializar un diccionario con clave compleja?
Mejor replantear la estructura o serializar como una lista de pares "key-value", donde la clave se serializa por completo como un objeto en vez de ser el nombre de una propiedad.

2
Tarea
C# SELF, nivel 46, lección 1
Bloqueada
Serialización y deserialización de un diccionario simple
Serialización y deserialización de un diccionario simple
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION