Collections & Generics

An array (Module 03) has a fixed length. List<T> is the collection you reach for when you do not know the size up front: it wraps an array and, when that array fills up, allocates a bigger one (double the size) and copies the items across. The <T> is a type argument — List<int> holds only ints, List<string> only strings — so the compiler checks every Add and you never cast on the way out.

var scores = new List<int> { 90, 72, 85 };
scores.Add(64);
scores.Insert(0, 100);          // insert at index 0
scores.Remove(72);              // removes the first 72

Console.WriteLine($"Count: {scores.Count}");
Console.WriteLine($"First: {scores[0]}, last: {scores[^1]}");
Console.WriteLine($"Has 85? {scores.Contains(85)}, index of 85: {scores.IndexOf(85)}");

scores.Sort();
Console.WriteLine(string.Join(", ", scores));

foreach (int s in scores)
{
    if (s >= 85) Console.Write(s + " ");
}
Console.WriteLine();

Count: 4
First: 100, last: 64
Has 85? True, index of 85: 2
64, 85, 90, 100
85 90 100

var scores = new List<int> { 90, 85 };
scores.Add("100");

Program.cs(2,12): error CS1503: Argument 1: cannot convert from 'string' to 'int'

var scores = new List<int> { 90, 85 };
scores.Add(100);
scores.Add(int.Parse("100"));

A Dictionary<TKey, TValue> maps unique keys to values using a hash table: the key's GetHashCode() picks a bucket, so a lookup costs O(1) on average no matter how many entries there are. Use it whenever you would otherwise search a list for "the item whose id is X".

var stock = new Dictionary<string, int>
{
    ["apple"] = 12,
    ["pear"] = 0,
};
stock["kiwi"] = 7;          // indexer set: adds or overwrites
stock["apple"] += 3;        // read, add, write back

if (stock.TryGetValue("pear", out int pears))
    Console.WriteLine($"pear: {pears}");

Console.WriteLine($"has mango? {stock.ContainsKey("mango")}");
Console.WriteLine($"mango or 0: {stock.GetValueOrDefault("mango")}");

stock.Remove("pear");
foreach (var (fruit, qty) in stock.OrderBy(p => p.Key))
    Console.WriteLine($"{fruit} = {qty}");

pear: 0
has mango? False
mango or 0: 0
apple = 15
kiwi = 7

var ages = new Dictionary<string, int>();
ages.Add("ana", 31);
ages.Add("ana", 32);

Unhandled exception. System.ArgumentException: An item with the same key has already been added. Key: ana
   at System.Collections.Generic.Dictionary`2.TryInsert(TKey key, TValue value, InsertionBehavior behavior)
   at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
   at Program.<Main>$(String[] args) in Program.cs:line 3

var ages = new Dictionary<string, int>();
ages["ana"] = 31;
ages["ana"] = 32;          // overwrite
bool added = ages.TryAdd("ana", 40); // false, value stays 32

HashSet<T> is a dictionary with keys only: O(1) "have I seen this?" checks and set maths. Queue<T> is first-in-first-out (a line at a shop); Stack<T> is last-in-first-out (a pile of plates, the undo button). SortedDictionary and SortedSet keep their keys in order at all times, at O(log n) per operation instead of O(1).

var seen = new HashSet<string>();
foreach (var tag in new[] { "c#", "linq", "c#", "async" })
{
    bool isNew = seen.Add(tag);          // false when already present
    Console.WriteLine($"{tag}: {(isNew ? "new" : "duplicate")}");
}

var a = new HashSet<int> { 1, 2, 3, 4 };
var b = new HashSet<int> { 3, 4, 5 };
a.IntersectWith(b);
Console.WriteLine("both: " + string.Join(",", a.Order()));

var line = new Queue<string>();
line.Enqueue("ana"); line.Enqueue("ben"); line.Enqueue("cy");
Console.WriteLine($"served {line.Dequeue()}, next is {line.Peek()}");

var undo = new Stack<string>();
undo.Push("type"); undo.Push("bold"); undo.Push("delete");
Console.WriteLine($"undo {undo.Pop()}, then {undo.Pop()}");

c#: new
linq: new
c#: duplicate
async: new
both: 3,4
served ana, next is ben
undo delete, then bold

var grades = new SortedDictionary<string, int>
{
    ["zoe"] = 88,
    ["ana"] = 95,
    ["mia"] = 71,
};
grades["ben"] = 80;

// always visited in key order, however you inserted them
foreach (var (name, grade) in grades)
    Console.WriteLine($"{name}: {grade}");

var sizes = new SortedSet<int> { 42, 7, 19, 7 };
Console.WriteLine($"min {sizes.Min}, max {sizes.Max}, count {sizes.Count}");

ana: 95
ben: 80
mia: 71
zoe: 88
min 7, max 42, count 3

Every collection above is written once and works for any T. You can do the same. A generic class puts the type parameter after the class name (class Box<T>); a generic method puts it after the method name (Swap<T>). At a call site the compiler usually infers T from the arguments, so you write Swap(ref x, ref y) rather than Swap<int>(ref x, ref y).

var name = new Box<string>("Ada");
var age = new Box<int>(36);
Console.WriteLine($"{name.Value} is {age.Value}");

int x = 1, y = 2;
Swap(ref x, ref y);                 // T inferred as int
Console.WriteLine($"x={x} y={y}");

var pair = new Pair<string, double>("pi", 3.14);
Console.WriteLine(pair);

static void Swap<T>(ref T a, ref T b)
{
    T tmp = a;
    a = b;
    b = tmp;
}

class Box<T>
{
    public T Value { get; }
    public Box(T value) => Value = value;
}

record Pair<TFirst, TSecond>(TFirst First, TSecond Second);

Ada is 36
x=2 y=1
Pair { First = pi, Second = 3.14 }

Inside a plain generic method the compiler knows nothing about T, so it only lets you do what works for every type: assign it, pass it, call ToString(). A where clause constrains T — "T must implement IComparable<T>" — and in return you may use those members.

Console.WriteLine(Max(3, 7));

static T Max<T>(T a, T b) => a > b ? a : b;

Program.cs(3,30): error CS0019: Operator '>' cannot be applied to operands of type 'T' and 'T'

Console.WriteLine(Max(3, 7));

static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) > 0 ? a : b;

Console.WriteLine(Max(3, 7));
Console.WriteLine(Max("pear", "apple"));
Console.WriteLine(Largest(new List<double> { 2.5, 9.1, 4.0 }));

var list = Make<List<int>>();
list.Add(1);
Console.WriteLine($"made a list with {list.Count} item");

static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) > 0 ? a : b;

static T Largest<T>(IEnumerable<T> items) where T : IComparable<T>
{
    T best = items.First();
    foreach (T item in items)
        if (item.CompareTo(best) > 0) best = item;
    return best;
}

static T Make<T>() where T : new() => new T();

7
pear
9.1
made a list with 1 item

using System.Numerics;

Console.WriteLine(Sum(new[] { 1, 2, 3 }));
Console.WriteLine(Sum(new[] { 1.5m, 2.25m }));

// generic math: one method for int, decimal, double, long...
static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
{
    T total = T.Zero;
    foreach (T v in values) total += v;
    return total;
}

6
3.75

IEnumerable<T> is the smallest collection interface in .NET: "you can walk through me with foreach". Arrays, lists, sets, dictionaries and every LINQ query implement it. Accept IEnumerable<T> as a parameter type when you only need to loop, and your method works with all of them.

A method whose return type is IEnumerable<T> can use yield return to hand out items one at a time. The compiler turns it into a state machine: the body does not run when you call the method, it runs piece by piece each time foreach asks for the next item. That makes infinite sequences possible, as long as the caller stops.

foreach (int n in Evens().Take(4))
    Console.Write(n + " ");
Console.WriteLine();

var seq = Countdown(3);          // nothing printed yet
Console.WriteLine("created");
foreach (int n in seq)
    Console.WriteLine($"got {n}");

static IEnumerable<int> Evens()
{
    for (int i = 0; ; i += 2)
        yield return i;           // infinite, but lazy
}

static IEnumerable<int> Countdown(int from)
{
    Console.WriteLine("start");
    for (int i = from; i > 0; i--)
        yield return i;
    Console.WriteLine("end");
}

0 2 4 6 
created
start
got 3
got 2
got 1
end

Covariance: why IEnumerable fits IEnumerable