How to iterate over a dictionary in C#

var stock = new Dictionary<string, int>
{
    ["apple"] = 12,
    ["banana"] = 0,
    ["cherry"] = 7,
};

// The canonical loop: one KeyValuePair<TKey, TValue> per entry.
foreach (KeyValuePair<string, int> pair in stock)
{
    Console.WriteLine($"{pair.Key} -> {pair.Value}");
}

// var infers KeyValuePair<string, int>; break and continue work as usual.
int units = 0;
foreach (var pair in stock)
{
    if (pair.Value == 0) continue;
    units += pair.Value;
}
Console.WriteLine($"units: {units}");

// .NET Core 2.0+: deconstruct the pair into two named variables.
foreach (var (fruit, count) in stock)
{
    Console.WriteLine($"{fruit,-7}{count,3}");
}

// A KeyValuePair prints as [key, value], so string.Join gives a quick dump.
Console.WriteLine(stock.First());
Console.WriteLine(string.Join(", ", stock));

// A comparer that counts hash lookups, so we can see what each loop costs.
var comparer = new CountingComparer();
var stock = new Dictionary<string, int>(comparer)
{
    ["apple"] = 12,
    ["banana"] = 0,
    ["cherry"] = 7,
};

// Keys only, values only: both are live views, not copies.
foreach (string fruit in stock.Keys)
{
    Console.WriteLine($"fruit: {fruit}");
}
Console.WriteLine($"units: {stock.Values.Sum()}, values: [{string.Join(", ", stock.Values)}]");

// The wasteful pattern: walk the keys, then look each one up again.
comparer.Lookups = 0;
int total = 0;
foreach (string fruit in stock.Keys)
{
    total += stock[fruit];
}
Console.WriteLine($"Keys + stock[key]: total {total}, lookups {comparer.Lookups}");

// Enumerating the pairs hands you the value with no lookup at all.
comparer.Lookups = 0;
total = 0;
foreach (var (_, count) in stock)
{
    total += count;
}
Console.WriteLine($"foreach pair:      total {total}, lookups {comparer.Lookups}");

// One key you are not sure exists: TryGetValue is a single lookup.
comparer.Lookups = 0;
if (stock.TryGetValue("cherry", out int cherries))
{
    Console.WriteLine($"cherry: {cherries}, lookups {comparer.Lookups}");
}

class CountingComparer : IEqualityComparer<string>
{
    public int Lookups;
    public bool Equals(string? x, string? y) => string.Equals(x, y);
    public int GetHashCode(string s)
    {
        Lookups++;
        return s.GetHashCode();
    }
}

using System.Runtime.InteropServices;

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

// The indexer setter adds a missing key or overwrites an existing one.
prices["coffee"] = 3.20m;
prices["juice"] = 4.00m;
Console.WriteLine(string.Join(", ", prices));

// Add() refuses a key that is already there; TryAdd() returns false instead.
try
{
    prices.Add("tea", 9.99m);
}
catch (ArgumentException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}
Console.WriteLine($"TryAdd tea: {prices.TryAdd("tea", 9.99m)}, tea is still {prices["tea"]}");

// Counting words: ++ on a missing key throws, so read with a default first.
string[] words = ["to", "be", "or", "not", "to", "be"];
var counts = new Dictionary<string, int>();
try
{
    counts["to"]++;
}
catch (KeyNotFoundException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}
foreach (string word in words)
{
    counts[word] = counts.GetValueOrDefault(word) + 1;
}
Console.WriteLine(string.Join(", ", counts));

// .NET 6+: one lookup that adds the key if needed and returns a ref to the value.
var fast = new Dictionary<string, int>();
foreach (string word in words)
{
    ref int slot = ref CollectionsMarshal.GetValueRefOrAddDefault(fast, word, out _);
    slot++;
}
Console.WriteLine(string.Join(", ", fast));

// Updating every value inside the loop: current .NET allows overwriting existing keys.
foreach (var (item, price) in prices)
{
    prices[item] = Math.Round(price * 1.1m, 2);
}
Console.WriteLine(string.Join(", ", prices));

// Code that must also run on .NET Framework loops over a copy of the keys.
foreach (string item in prices.Keys.ToList())
{
    prices[item] -= 0.25m;
}
Console.WriteLine(string.Join(", ", prices));

var scores = new Dictionary<string, int>
{
    ["alice"] = 90,
    ["bob"] = 45,
    ["carol"] = 72,
    ["dana"] = 30,
};

// .NET Core 3.0+: Remove() inside the foreach is allowed for Dictionary<TKey, TValue>.
var passed = new Dictionary<string, int>(scores);
foreach (var (name, score) in passed)
{
    if (score < 50) passed.Remove(name);
}
Console.WriteLine($"remove in loop:  {string.Join(", ", passed)}");

// Adding a key during the loop still breaks the enumerator.
var broken = new Dictionary<string, int>(scores);
try
{
    foreach (var (name, score) in broken)
    {
        broken[name + "-retake"] = score + 10;
    }
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}
Console.WriteLine($"entries now: {broken.Count}");

// Works everywhere: collect the keys first, then remove them.
var kept = new Dictionary<string, int>(scores);
var failing = kept.Where(pair => pair.Value < 50).Select(pair => pair.Key).ToList();
foreach (string name in failing)
{
    kept.Remove(name);
}
Console.WriteLine($"collect, remove: {string.Join(", ", kept)} (dropped {string.Join(", ", failing)})");

// Or build a new dictionary with only the entries you want.
var filtered = scores.Where(pair => pair.Value >= 50).ToDictionary();
Console.WriteLine($"ToDictionary():  {string.Join(", ", filtered)}");

var ports = new Dictionary<string, int>
{
    ["http"] = 80,
    ["https"] = 443,
    ["ssh"] = 22,
};
Console.WriteLine($"Dictionary:        {string.Join(", ", ports.Keys)}");

// Order is undefined: after a Remove, the next new key can take the freed slot.
ports.Remove("http");
ports["dns"] = 53;
Console.WriteLine($"after Remove, Add: {string.Join(", ", ports.Keys)}");

// Need an order? Sort while you iterate (the dictionary itself is unchanged)...
foreach (var (name, port) in ports.OrderBy(pair => pair.Key))
{
    Console.WriteLine($"  {name} = {port}");
}
Console.WriteLine($"by value, desc:    {string.Join(", ", ports.OrderByDescending(pair => pair.Value))}");

// ...or use a collection that keeps its keys sorted all the time.
var sorted = new SortedDictionary<string, int>(ports);
sorted["ftp"] = 21;
Console.WriteLine($"SortedDictionary:  {string.Join(", ", sorted.Keys)}");

// .NET 9+: OrderedDictionary<TKey, TValue> keeps insertion order and has indexes.
var ordered = new OrderedDictionary<string, int> { ["https"] = 443, ["ssh"] = 22 };
ordered.Remove("https");
ordered["dns"] = 53;
ordered.Insert(0, "ftp", 21);
Console.WriteLine($"OrderedDictionary: {string.Join(", ", ordered.Keys)}; first is {ordered.GetAt(0)}");

var defaults = new Dictionary<string, string> { ["theme"] = "light", ["lang"] = "en", ["font"] = "mono" };
var user = new Dictionary<string, string> { ["theme"] = "dark", ["zoom"] = "125%" };

// Last one wins: copy the first, then let the indexer overwrite from the second.
var settings = new Dictionary<string, string>(defaults);
foreach (var (key, value) in user)
{
    settings[key] = value;
}
Console.WriteLine($"indexer: {string.Join(", ", settings)}");

// First one wins: TryAdd skips keys that are already there.
var keepFirst = new Dictionary<string, string>(defaults);
foreach (var (key, value) in user)
{
    keepFirst.TryAdd(key, value);
}
Console.WriteLine($"TryAdd:  {string.Join(", ", keepFirst)}");

// Concat + ToDictionary is one line, but it throws on a duplicate key.
try
{
    var merged = defaults.Concat(user).ToDictionary();
}
catch (ArgumentException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// Any number of dictionaries, with your own rule for duplicates (here: add them up).
Dictionary<string, int>[] sales =
[
    new() { ["north"] = 10, ["south"] = 4 },
    new() { ["south"] = 6, ["east"] = 3 },
    new() { ["north"] = 1 },
];
var totals = sales
    .SelectMany(dict => dict)
    .GroupBy(pair => pair.Key)
    .ToDictionary(group => group.Key, group => group.Sum(pair => pair.Value));
Console.WriteLine($"summed:  {string.Join(", ", totals)}");