C# Lists and Dictionaries

var tasks = new List<string> { "Write report", "Email Sam" };
tasks.Add("Book train");            // add to the end
tasks.Insert(0, "Coffee");          // add at a position
tasks.Remove("Email Sam");          // remove by value
tasks.RemoveAt(0);                  // remove by index

Console.WriteLine(tasks.Count);     // 2
Console.WriteLine(tasks[0]);        // Write report

• Count is the number of items (arrays use Length, lists use Count).
• Contains, IndexOf, Find(predicate) and Exists(predicate) search the list.
• Sort() sorts in place, and RemoveAll(predicate) removes every matching item.
• List<string> names = []; is a short way to create an empty list in C# 12.

var prices = new Dictionary<string, decimal>
{
    ["apple"] = 0.50m,
    ["bread"] = 1.20m
};
prices["milk"] = 0.95m;            // add or replace
prices.Remove("apple");

if (prices.TryGetValue("bread", out decimal price))
{
    Console.WriteLine(price);       // 1.20
}

• Keys are unique; setting prices["milk"] again replaces the value.
• Reading a key that doesn't exist with prices["tea"] throws a KeyNotFoundException, so use TryGetValue or ContainsKey when the key might be missing.
• Add(key, value) throws if the key already exists, which is useful when duplicates would be a bug.
• Looping gives KeyValuePair items: foreach (var (name, cost) in prices).

• HashSet<T> ignores duplicates. Add returns false if the item was already there. UnionWith, IntersectWith and ExceptWith combine sets.
• Queue<T> is first in, first out: Enqueue adds to the back and Dequeue takes from the front, like a line at a shop.
• Stack<T> is last in, first out: Push and Pop, like an undo history.

Counting things is one of the most common jobs for a dictionary. GetValueOrDefault returns 0 for a missing int key, so you don't need an if to handle the first time you see a word:

var counts = new Dictionary<string, int>();
foreach (string word in "the cat and the hat".Split(' '))
{
    counts[word] = counts.GetValueOrDefault(word) + 1;
}
Console.WriteLine(counts["the"]);   // 2

TryAdd(key, value) adds only when the key is new and returns false instead of throwing when it already exists, which is handy for "first one wins" rules.

A Dictionary makes no promise about the order of its items. To show results in a particular order, sort them as you loop:

foreach (var (word, n) in counts.OrderByDescending(p => p.Value))
    Console.WriteLine($"{word}: {n}");

If the keys should always stay sorted, use SortedDictionary<TKey, TValue> instead. It keeps keys in order as you add them, at the cost of slightly slower lookups than a normal Dictionary.

Keys are compared exactly by default, so "Apple" and "apple" are different keys. Pass a comparer when you create the dictionary to ignore case:

var stock = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);