C# Academy · Lezione

Ricerche nei dizionari

Accesso rapido chiave-valore.

Ricerche nei dizionari è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Coppie chiave-valore

Dictionary<TKey, TValue> associa chiavi univoche a valori. Lo consideri una tabella di ricerca: gli fornisca una chiave e otterrà rapidamente il valore corrispondente.

È basato su una tabella hash, quindi trovare un valore tramite chiave ha in media un costo O(1), molto più basso rispetto alla scansione di una lista.

using System.Collections.Generic;

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

Inizializzazione di un Dictionary

È possibile inizializzare un dizionario con un inizializzatore di raccolta. Ogni voce associa una chiave al relativo valore.

Le chiavi devono essere univoche. Specificare due volte la stessa chiave in un inizializzatore genera un'ArgumentException in fase di esecuzione.

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"]);
    }
}

Lettura tramite chiave

Utilizzi l'indicizzatore per leggere: dict[key]. In media, questa operazione è O(1).

Ma faccia attenzione: se la chiave non esiste, l'indicizzatore genera KeyNotFoundException. La lettura di una chiave assente è uno degli errori più comuni nell'uso dei dizionari.

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

Ricerca sicura con TryGetValue

TryGetValue evita le eccezioni. Restituisce true e assegna un valore a una variabile out quando la chiave esiste, oppure false in caso contrario.

È il modo idiomatico e senza allocazioni per cercare un valore di cui non si è certi.

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 e valori predefiniti

ContainsKey verifica la presenza di una chiave senza leggere il valore, in O(1). Lo utilizzi prima di una lettura tramite indicizzatore quando le serve solo una risposta sì o no.

Se chiama sia ContainsKey sia l'indicizzatore, calcola l'hash della chiave due volte. TryGetValue lo fa una sola volta, quindi di solito è più veloce.

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

Aggiunta e assegnazione

L'indicizzatore dict[key] = value inserisce una nuova coppia o sovrascrive quella esistente. Add(key, value) inserisce soltanto una nuova coppia e genera un'eccezione se la chiave esiste già.

Utilizzi Add quando una chiave duplicata deve essere considerata un errore, e l'indicizzatore quando sovrascrivere è accettabile.

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"]);
    }
}

Rimozione delle voci

Remove(key) elimina una coppia e restituisce true se la chiave era presente; in media ha complessità O(1).

Un overload restituisce il valore rimosso tramite un parametro out, utile quando desidera eliminare una voce e utilizzare il valore in un unico passaggio.

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

Iterazione sulle coppie

Un ciclo restituisce elementi KeyValuePair<TKey, TValue>. Li decomponga in una chiave e un valore per ottenere un codice più leggibile.

L'ordine di enumerazione non è garantito: non faccia mai affidamento sull'ordine in cui sono state inserite le voci. Utilizzi Keys o Values per iterare solo su uno dei due lati.

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}");
    }
}

Conteggio con un dizionario

Un utilizzo classico consiste nel conteggiare le occorrenze. Per ogni elemento, incrementi il conteggio, partendo da zero se è nuovo.

Questo schema viene eseguito in O(n) per n elementi, perché ogni ricerca e aggiornamento è O(1), invece di O(n al quadrato) se ogni volta si eseguisse una scansione di una lista.

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']);
    }
}

L'uguaglianza delle chiavi è importante

Le ricerche si basano su GetHashCode e Equals del tipo della chiave. I tipi incorporati e string funzionano immediatamente.

Per le chiavi di classi personalizzate, esegua l'override di entrambi i metodi oppure utilizzi un record; in caso contrario, due chiavi apparentemente uguali producono hash diversi e le ricerche hanno esito negativo.

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

Scelta del tipo del valore

I valori possono essere di qualsiasi tipo, incluse le liste. Un Dictionary<string, List<int>> raggruppa più valori sotto un'unica chiave.

Quando inserisce dati in una struttura di questo tipo, crei la lista interna al primo utilizzo, quindi vi aggiunga l'elemento. In questo modo costruisce una mappa raggruppata con più valori.

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);
}

Verifica rapida

Scelga il modo più sicuro per leggere una chiave che potrebbe non esistere.

Riepilogo

Dictionary<K,V> offre, in media, operazioni O(1) di ricerca, inserimento e rimozione tramite chiave, grazie a una tabella hash.

Preferisca TryGetValue all'indicizzatore che genera eccezioni, mantenga le chiavi univoche e si assicuri che i tipi di chiave personalizzati implementino correttamente l'uguaglianza e l'hashing. L'ordine di iterazione non è definito.

Domande Frequenti

La lezione «Ricerche nei dizionari» è gratuita?

Sì — il testo completo di «Ricerche nei dizionari» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Ricerche nei dizionari»?

Accesso rapido chiave-valore. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Ricerche nei dizionari»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy