Dictionary C#: Add, TryGetValue, Iterasi, dan Sort

Dictionary<TKey, TValue> menyimpan value di bawah key yang unik dan menemukan sebuah value berdasarkan key-nya dalam waktu yang kurang lebih konstan, berapa pun jumlah entrinya. Ini padanan hash map di C#: buku telepon dari nama ke nomor, cache dari ID ke record, atau jumlah kemunculan per kata.

Membuat dictionary dan membaca value

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var stock = new Dictionary<string, int>();
        stock["apples"] = 12;
        stock["pears"] = 0;

        var prices = new Dictionary<string, decimal>
        {
            ["coffee"] = 3.20m,
            ["tea"] = 2.50m,
        };

        var capitals = new Dictionary<string, string>
        {
            { "France", "Paris" },
            { "Peru", "Lima" },
        };

        Console.WriteLine(stock["apples"]);
        Console.WriteLine(prices["tea"]);
        Console.WriteLine(capitals.Count);
        Console.WriteLine(capitals.ContainsKey("Peru"));
        Console.WriteLine(capitals.ContainsValue("Rome"));
    }
}

Output:

12
2.50
2
True
False

Kedua bentuk initializer melakukan hal yang sama. Bentuk ["key"] = value (C# 6) memakai indexer, jadi key yang berulang akan menimpa; bentuk { key, value } memanggil Add, jadi key yang berulang melempar exception saat baris itu dijalankan.

ContainsKey adalah pencarian hash dan cepat. ContainsValue harus memindai setiap entri, karena value tidak diindeks.

Add vs indexer vs TryAdd

Ada tiga cara untuk memasukkan entri, dan bedanya hanya pada apa yang terjadi saat key-nya sudah ada:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var ages = new Dictionary<string, int>();

        ages.Add("Ana", 31);
        ages["Ben"] = 25;     // new key: inserted
        ages["Ben"] = 26;     // existing key: overwritten
        Console.WriteLine(ages["Ben"]);

        try
        {
            ages.Add("Ana", 40); // duplicate key
        }
        catch (ArgumentException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        Console.WriteLine(ages.TryAdd("Chloe", 22)); // new: added
        Console.WriteLine(ages.TryAdd("Ana", 99));   // exists: not added
        Console.WriteLine(ages["Ana"]);
    }
}

Output:

26
Caught ArgumentException
True
False
31

Add yang melempar exception untuk key duplikat adalah sebuah fitur: hal ini memunculkan data yang seharusnya unik tetapi ternyata tidak. Pakai indexer saat maksudmu "sisipkan atau perbarui", dan TryAdd (.NET Core 2.0 ke atas) saat value pertama yang harus menang.

Key tidak boleh null. Add(null, ...) atau dict[null] melempar ArgumentNullException. Value boleh null kalau tipe value-nya mengizinkan.

KeyNotFoundException dan TryGetValue

Membaca key yang tidak ada dengan indexer melempar KeyNotFoundException. Ini error dictionary yang paling umum, dan solusinya hampir selalu TryGetValue.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var emails = new Dictionary<int, string>
        {
            [101] = "ana@example.com",
            [102] = "ben@example.com",
        };

        try
        {
            Console.WriteLine(emails[999]);
        }
        catch (KeyNotFoundException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        if (emails.TryGetValue(101, out string email))
        {
            Console.WriteLine("Found " + email);
        }

        if (!emails.TryGetValue(999, out string none))
        {
            Console.WriteLine("Missing, value is null: " + (none == null));
        }

        string fallback = emails.TryGetValue(103, out var e3) ? e3 : "no email";
        Console.WriteLine(fallback);
    }
}

Output:

Caught KeyNotFoundException
Found ana@example.com
Missing, value is null: True
no email

TryGetValue melakukan satu kali pencarian hash dan melaporkan keberhasilannya sebagai bool. Pola if (dict.ContainsKey(k)) { var v = dict[k]; } memang berfungsi, tetapi mencari key-nya dua kali. Saat key-nya tidak ada, variabel out mendapat nilai default tipenya (null, 0, false).

Di .NET Core 2.0 ke atas juga ada GetValueOrDefault(key, fallback), yang mengembalikan nilai cadangan saat key-nya tidak ada: emails.GetValueOrDefault(103, "no email").

Memperbarui dan menghapus entri

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var cart = new Dictionary<string, int> { ["milk"] = 1, ["eggs"] = 6 };

        cart["milk"] += 1;                     // read, add, write back
        Console.WriteLine(cart["milk"]);

        Console.WriteLine(cart.Remove("eggs")); // true: removed
        Console.WriteLine(cart.Remove("rice")); // false: was not there
        Console.WriteLine(cart.Count);

        cart.Clear();
        Console.WriteLine(cart.Count);
    }
}

Output:

2
True
False
1
0

cart["milk"] += 1 melempar KeyNotFoundException kalau milk belum ada di dictionary, karena operasi ini membaca dulu sebelum menulis. Remove mengembalikan false alih-alih melempar exception untuk key yang tidak ada, jadi tidak perlu mengecek ContainsKey lebih dulu.

Iterasi: KeyValuePair, Keys, dan Values

foreach pada dictionary menghasilkan item KeyValuePair<TKey, TValue>, masing-masing dengan Key dan Value.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var scores = new Dictionary<string, int>
        {
            ["Ana"] = 88,
            ["Ben"] = 72,
            ["Chloe"] = 95,
        };

        foreach (KeyValuePair<string, int> pair in scores)
        {
            Console.WriteLine(pair.Key + ": " + pair.Value);
        }

        foreach (string name in scores.Keys)
        {
            Console.Write(name + " ");
        }
        Console.WriteLine();

        int total = 0;
        foreach (int s in scores.Values) total += s;
        Console.WriteLine("Total " + total);

        // Change values: loop over a copy of the keys.
        foreach (string name in new List<string>(scores.Keys))
        {
            scores[name] += 5;
        }
        Console.WriteLine(scores["Ben"]);
    }
}

Output:

Ana: 88
Ben: 72
Chloe: 95
Ana Ben Chloe 
Total 255
77

pair.Value bersifat read-only, jadi memperbarui value berarti menulis lewat indexer. Loop terakhir melakukan iterasi pada salinan key berupa List<string>, yang selalu aman; iterasi langsung pada scores.Keys sambil menimpa value yang sudah ada diizinkan di .NET Core 3.0 ke atas, tetapi melempar InvalidOperationException di .NET Framework.

Menambahkan key baru di dalam foreach pada dictionary yang sama melempar InvalidOperationException di semua versi. Menghapus selama iterasi melempar exception di .NET Framework dan diizinkan sejak .NET Core 3.0. Kode yang harus berjalan di mana saja mengumpulkan key yang akan dihapus lebih dulu, lalu menghapusnya setelah loop.

Dengan C# 7 dan .NET Core 2.0 ke atas, KeyValuePair bisa di-deconstruct di header loop:

foreach (var (name, score) in scores)
{
    Console.WriteLine($"{name}: {score}");
}

Menghitung dengan dictionary

Menghitung kemunculan adalah penggunaan klasiknya. Baca jumlah saat ini dengan TryGetValue (key yang tidak ada memberi 0), lalu tulis kembali.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        string text = "the cat and the dog and the bird";
        var counts = new Dictionary<string, int>();

        foreach (string word in text.Split(' '))
        {
            counts.TryGetValue(word, out int n); // n is 0 when missing
            counts[word] = n + 1;
        }

        foreach (var pair in counts)
        {
            Console.WriteLine(pair.Key + " " + pair.Value);
        }
    }
}

Output:

the 3
cat 1
and 2
dog 1
bird 1

Bentuk yang sama juga bisa mengelompokkan item: Dictionary<string, List<Order>>, saat kamu mengambil list-nya dengan TryGetValue, membuat dan menyimpan list baru kalau belum ada, lalu memanggil Add padanya. Untuk menghitung dan mengelompokkan sekali jalan, LINQ melakukannya dalam satu ekspresi: words.GroupBy(w => w).ToDictionary(g => g.Key, g => g.Count()). Lihat LINQ.

Key yang tidak peka huruf besar-kecil dengan comparer

Secara default, key string dibandingkan secara persis: "Apple" dan "apple" adalah dua key. Berikan IEqualityComparer<string> ke constructor untuk mengubahnya.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var exact = new Dictionary<string, int>();
        exact["Apple"] = 1;
        Console.WriteLine(exact.ContainsKey("apple"));

        var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        headers["Content-Type"] = "text/html";
        Console.WriteLine(headers["content-type"]);
        headers["CONTENT-TYPE"] = "application/json"; // same key: overwrites
        Console.WriteLine(headers.Count);
    }
}

Output:

False
text/html
1

StringComparer.OrdinalIgnoreCase adalah pilihan yang tepat untuk identifier seperti header HTTP, ekstensi file, dan username. Memanggil .ToLower() pada setiap key sebelum menyimpannya juga berfungsi, tetapi mudah terlupa di satu tempat.

Untuk key berupa class buatanmu sendiri, dictionary memanggil GetHashCode dan Equals milik key itu. Class yang tidak meng-override keduanya dibandingkan berdasarkan reference, jadi dua object terpisah dengan field yang sama dianggap key yang berbeda. Lihat HashSet untuk cara menulis pasangan method itu.

Urutan, pengurutan, dan SortedDictionary

Dictionary tidak menjanjikan urutan iterasi apa pun. Dalam praktiknya, dictionary yang hanya pernah ditambahi entri diiterasi sesuai urutan penambahan, tetapi setelah Remove, Add berikutnya bisa memakai ulang slot yang kosong dan muncul lebih awal. Kode tidak boleh bergantung pada hal ini.

Saat kamu butuh urutan, urutkan di tempat data dipakai atau pakai koleksi yang terurut:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var sales = new Dictionary<string, int>
        {
            ["Lima"] = 340,
            ["Oslo"] = 520,
            ["Cairo"] = 210,
        };

        foreach (var pair in sales.OrderBy(p => p.Key))
            Console.WriteLine(pair.Key + " " + pair.Value);

        Console.WriteLine("By value, highest first:");
        foreach (var pair in sales.OrderByDescending(p => p.Value))
            Console.WriteLine(pair.Key + " " + pair.Value);

        var sorted = new SortedDictionary<string, int>(sales);
        sorted["Berlin"] = 90;
        Console.WriteLine(string.Join(", ", sorted.Keys));
    }
}

Output:

Cairo 210
Lima 340
Oslo 520
By value, highest first:
Oslo 520
Lima 340
Cairo 210
Berlin, Cairo, Lima, Oslo

SortedDictionary<TKey, TValue> menjaga key-nya selalu terurut (strukturnya balanced tree), jadi pencarian dan penyisipan bernilai O(log n), bukan O(1). Pakai saat kamu sering melakukan iterasi berdasarkan urutan key; urutkan dictionary biasa dengan LINQ kalau kamu hanya butuh urutan sekali. SortedList<TKey, TValue> adalah pilihan ketiga yang memakai lebih sedikit memori, tetapi lambat untuk penyisipan saat ukurannya besar.

Referensi singkat

Kesalahan umum

• Membaca key yang tidak ada dengan d[k]. Melempar KeyNotFoundException; pakai TryGetValue.
• Memanggil Add untuk key yang mungkin sudah ada. Melempar ArgumentException; pakai indexer atau TryAdd.
• Menambahkan key di dalam foreach pada dictionary itu. Melempar InvalidOperationException; kumpulkan perubahannya dan terapkan setelahnya.
• Bergantung pada urutan iterasi. Urutkan, atau pakai SortedDictionary.
• Mengubah field object key setelah menyisipkannya. Hash code-nya berubah dan entrinya tidak bisa ditemukan lagi.
• ContainsKey lalu indexer. Dua kali pencarian; TryGetValue cukup sekali.