📝 Lesson 1.3: Collections in Depth

Beyond the List

A List<T> is a great general-purpose collection, but it's not always the best tool. Suppose you want to look up a person's phone number by their name. With a list you'd have to loop through every entry checking names — slow, and awkward to write.

The .NET class library (all generic, thanks to Lesson 1.2) includes collections designed for exactly these situations. Each is optimized for a specific access pattern:

All of these live in System.Collections.Generic, which modern projects include automatically.

Dictionary: Key/Value Lookups

A Dictionary<TKey, TValue> stores pairs: each unique key maps to a value. Look up a value by its key directly — no looping. It's like a real dictionary: look up a word (key) to get its definition (value).

Dictionary<string, int> ages = new Dictionary<string, int>();

ages["Ada"] = 30;          // add or update by key
ages["Grace"] = 45;
ages.Add("Alan", 41);      // Add also works (throws if key exists)

Console.WriteLine(ages["Grace"]);   // 45 — instant lookup, no loop
Console.WriteLine(ages.Count);      // 3

if (ages.TryGetValue("Bob", out int bobAge))
{
    Console.WriteLine($"Bob is {bobAge}.");
}
else
{
    Console.WriteLine("Bob isn't in the dictionary.");
}

// Or just test membership:
if (ages.ContainsKey("Ada")) { /* ... */ }

Loop over a dictionary with foreach; each item is a KeyValuePair with .Key and .Value:

foreach (KeyValuePair<string, int> entry in ages)
{
    Console.WriteLine($"{entry.Key} is {entry.Value}");
}

// You can also loop just the keys or just the values:
foreach (string name in ages.Keys) { Console.WriteLine(name); }

HashSet: Unique Items

A HashSet<T> stores a collection of unique values — duplicates are silently ignored — and answers "is this item present?" extremely fast.

HashSet<string> visitors = new HashSet<string>();

visitors.Add("Ada");
visitors.Add("Grace");
Console.WriteLine(visitors.Add("Ada"));   // False — already present, not added

Console.WriteLine(visitors.Count);         // 2 (no duplicate)
Console.WriteLine(visitors.Contains("Grace"));  // True — fast membership test

A common use is de-duplicating: drop a list into a set and the duplicates disappear.

List<int> numbers = new List<int> { 1, 2, 2, 3, 3, 3 };
HashSet<int> unique = new HashSet<int>(numbers);
Console.WriteLine(unique.Count);   // 3

Queue and Stack

These two hold items in a specific processing order.

Queue<T> — First In, First Out (FIFO)

Like a line at a shop: the first person to join is the first served. Add with Enqueue, remove the oldest with Dequeue.

Queue<string> line = new Queue<string>();
line.Enqueue("Ada");
line.Enqueue("Grace");
line.Enqueue("Alan");

Console.WriteLine(line.Dequeue());   // Ada  (first in, first out)
Console.WriteLine(line.Peek());      // Grace (next up, without removing)
Console.WriteLine(line.Count);       // 2

Stack<T> — Last In, First Out (LIFO)

Like a stack of plates: the last one placed is the first taken. Add with Push, remove the newest with Pop.

Stack<string> history = new Stack<string>();
history.Push("page1");
history.Push("page2");
history.Push("page3");

Console.WriteLine(history.Pop());    // page3 (last in, first out)
Console.WriteLine(history.Peek());   // page2 (top, without removing)

Why the Right Choice Is Faster

This isn't just about tidy code — it's about speed. Finding an item in a List means potentially checking every element. A Dictionary or HashSet jumps almost straight to it, using a technique called hashing.

💡 The practical rule: If your code loops through a List just to find something by a key or to check membership, a Dictionary or HashSet is almost certainly the better choice — often dramatically faster as the data grows.

Choosing a Collection

A quick decision guide you can keep handy:

Exercise & Quiz

string sentence = "the cat sat on the mat the cat purred";
string[] words = sentence.Split(' ');

Dictionary<string, int> counts = new Dictionary<string, int>();

// TODO: loop over words, count each into the dictionary

// TODO: print each word and its count

string sentence = "the cat sat on the mat the cat purred";
string[] words = sentence.Split(' ');

Dictionary<string, int> counts = new Dictionary<string, int>();

foreach (string word in words)
{
    if (counts.ContainsKey(word))
    {
        counts[word]++;
    }
    else
    {
        counts[word] = 1;
    }
}

foreach (KeyValuePair<string, int> entry in counts)
{
    Console.WriteLine($"{entry.Key}: {entry.Value}");
}

// Bonus: distinct word count
HashSet<string> distinct = new HashSet<string>(words);
Console.WriteLine($"Distinct words: {distinct.Count}");

the: 3
cat: 2
sat: 1
on: 1
mat: 1
purred: 1
Distinct words: 6

Summary

📚 Additional Resources

• Dictionary<TKey,TValue> — API reference
• HashSet<T> — API reference
• Collections and Data Structures — overview

🚀 What's Next?

That completes Module 1 — you can write robust, reusable, well-structured code. In Module 2, C# gets expressive. First up, Lesson 2.1: Delegates and Lambdas, where you'll learn to treat behavior itself as data you can pass around.