C# Academy · Lección

Búsquedas en Dictionary

Acceso rápido mediante clave-valor

Búsquedas en Dictionary es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Pares clave-valor

Dictionary<TKey, TValue> asigna valores a claves únicas. Piense en él como una tabla de búsqueda: proporciónele una clave y obtendrá rápidamente el valor correspondiente.

Se basa en una tabla hash, por lo que encontrar un valor mediante su clave cuesta O(1) como promedio, mucho menos que recorrer una lista.

using System.Collections.Generic;

var ages = new Dictionary<string, int>();
ages["Ann"] = 30;
ages["Bob"] = 25;

Inicializar un diccionario

Puede precargar un diccionario mediante un inicializador de colección. Cada entrada asocia una clave con su valor.

Las claves deben ser únicas. Proporcionar dos veces la misma clave en un inicializador produce una ArgumentException en tiempo de ejecución.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var caps = new Dictionary<string, string> {
            ["FR"] = "Paris",
            ["JP"] = "Tokyo"
        };
        Console.WriteLine(caps["JP"]);
    }
}

Lectura por clave

Utilice el indexador para leer: dict[key]. Esto es O(1) en promedio.

Pero tenga cuidado: si falta la clave, el indexador lanza KeyNotFoundException. Leer una clave ausente es uno de los errores más comunes al trabajar con diccionarios.

var ages = new Dictionary<string, int> { ["Ann"] = 30 };
int a = ages["Ann"];      // 30
// int b = ages["Zoe"];   // throws KeyNotFoundException

Consulta segura con TryGetValue

TryGetValue evita las excepciones. Devuelve true y asigna una variable out cuando existe la clave, o false en caso contrario.

Esta es la forma idiomática y sin asignaciones de consultar un valor cuya existencia no tiene certeza.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var ages = new Dictionary<string, int> { ["Ann"] = 30 };
        if (ages.TryGetValue("Ann", out int v))
            Console.WriteLine(v);
    }
}

ContainsKey y valores predeterminados

ContainsKey comprueba si existe una clave sin leer el valor, en O(1). Utilícelo antes de leer con el indexador cuando solo necesite una respuesta afirmativa o negativa.

Si llama tanto a ContainsKey como al indexador, calcula el hash de la clave dos veces. TryGetValue lo hace una sola vez, por lo que normalmente es más rápido.

var ages = new Dictionary<string, int> { ["Ann"] = 30 };
if (ages.ContainsKey("Ann"))
    System.Console.WriteLine(ages["Ann"]);

Agregar frente a asignar

El indexador dict[key] = value inserta un par nuevo o sobrescribe uno existente. Add(key, value) solo inserta y lanza una excepción si la clave ya existe.

Utilice Add cuando una clave duplicada deba ser un error, y el indexador cuando sobrescribir sea aceptable.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var d = new Dictionary<string, int>();
        d["x"] = 1;
        d["x"] = 2;     // overwrite, fine
        Console.WriteLine(d["x"]);
    }
}

Eliminar entradas

Remove(key) elimina un par y devuelve true si la clave estaba presente, en O(1) en promedio.

Una sobrecarga devuelve el valor eliminado mediante un parámetro out, lo que resulta práctico cuando desea eliminar el valor y utilizarlo en un solo paso.

var d = new Dictionary<string, int> { ["a"] = 1, ["b"] = 2 };
bool removed = d.Remove("a");   // true
bool again = d.Remove("a");     // false

Iterar pares

Los bucles devuelven elementos KeyValuePair<TKey, TValue>. Desestructúrelos en una clave y un valor para obtener un código más claro.

El orden de enumeración no está garantizado; nunca dependa del orden en que se insertaron las entradas. Utilice Keys o Values para iterar solo por una de las partes.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var d = new Dictionary<string, int> { ["a"] = 1, ["b"] = 2 };
        foreach (var (key, val) in d)
            Console.WriteLine($"{key}={val}");
    }
}

Contar con un Dictionary

Un uso clásico consiste en contar apariciones. Para cada elemento, incremente su contador, empezando desde cero si es nuevo.

Este patrón se ejecuta en O(n) para n elementos, porque cada consulta y actualización es O(1), frente a O(n²) si recorriera una lista cada vez.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var counts = new Dictionary<char, int>();
        foreach (char c in "banana")
            counts[c] = counts.GetValueOrDefault(c) + 1;
        Console.WriteLine(counts['a']);
    }
}

La igualdad de las claves es importante

Las consultas dependen de GetHashCode y Equals del tipo de la clave. Los tipos integrados y string funcionan directamente.

Para las claves de clases personalizadas, sobrescriba ambos métodos (o utilice un record); de lo contrario, dos claves que parecen iguales generarán hashes distintos y las consultas fallarán.

var byName = new Dictionary<string, int>(
    System.StringComparer.OrdinalIgnoreCase);
byName["Hi"] = 1;
bool found = byName.ContainsKey("HI"); // true

Elegir un tipo de valor

Los valores pueden ser cualquier cosa, incluidas listas. Un Dictionary<string, List<int>> agrupa muchos valores bajo una misma clave.

Al insertar en una estructura de este tipo, cree la lista interna la primera vez que la utilice y después agregue elementos. Así se construye un mapa agrupado de valores múltiples.

var groups = new Dictionary<string, List<int>>();
void Add(string k, int v) {
    if (!groups.TryGetValue(k, out var list))
        groups[k] = list = new List<int>();
    list.Add(v);
}

Comprobación rápida

Elija la forma más segura de leer una clave que podría no existir.

Resumen

Dictionary<K,V> ofrece consultas, inserciones y eliminaciones por clave en O(1) en promedio, respaldadas por una tabla hash.

Prefiera TryGetValue al indexador que lanza excepciones, mantenga las claves únicas y asegúrese de que los tipos de claves personalizados implementen una igualdad y un cálculo de hash adecuados. El orden de iteración no está definido.

Preguntas frecuentes

¿La lección «Búsquedas en Dictionary» es gratis?

Sí — el texto completo de «Búsquedas en Dictionary» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Búsquedas en Dictionary»?

Acceso rápido mediante clave-valor Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Búsquedas en Dictionary»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy