What are collections in C#? Compare an array, ArrayList and List<T>; what is the difference between IEnumerable, ICollection and IList; what is HashSet, and which collection would you use when?

Say it out loud, then check

One statement run, every collection

The BMW FS month-end statement run, in the order the data meets each collection. Each type is there because of one property: fixed length, order, uniqueness, or lookup by key.

The story

1. Before

   BMW FS's dealer portal kept its open contracts in one shared ContractCache, a store of data kept in memory so the next caller does not rebuild it: a private List<Contract> loaded at start-up, read by the portal on every page. A nightly stock report also needed those contracts. It asked the cache for them, printed them, and then called Clear to free memory after the run. Within a minute the portal was showing zero open contracts to every dealer, until the next refresh loaded the cache again.

2. Why it had to change

   List<T> is a reference type: the variable holds an address to the object, not the list. So cache.Open() handed the report the cache's own list, and open in the report was a second name for it (a reference). Clear does exactly what it says on that one list: the portal's next read found nothing. Nothing threw, because every call was legal; the code did what the developer asked, just not what they meant.

3. How it works now

   The fix changes the promise, not the data. IReadOnlyList<T> is an interface with an index and Count, but no Add or Clear. AsReadOnly returns a ReadOnlyCollection wrapper around the same list: the portal keeps reading the live cache, with no copy, while the report's Clear stops compiling. A compile error is cheaper than an incident.

4. What we gained

   The portal kept its contracts and the report kept working. The bigger gain is the rule: any class that owns a collection decides what callers may do with it, and returns the narrowest interface that still does the job. A caller that needs to loop gets IEnumerable<T>; one that needs to read by index gets IReadOnlyList<T>; only the owner keeps the List<T>.

In the lending API

The fix is the return type: the cache hands out a read-only view, not its own list.

Only the key lines are shown; Deep walks the whole file.

The code, file by file

The cache and the report that cleared it, before and after. The contract model comes first; tap Next to follow the run.

What they ask next

The follow-ups interviews really ask. Answer out loud, then tap to check.

• ReportedWhat is the difference between IEnumerable, ICollection and IList?

  They are a ladder of promises. IEnumerable<T> gives you foreach and nothing else. ICollection<T> adds Count, Add, Remove, Contains and Clear. IList<T> adds the indexer, Insert, RemoveAt and IndexOf. A List<T> implements all three, so the same object can be handed out through any of them; the interface you choose tells the caller what they are allowed to do.

  IEnumerable<Contract> loop = list;
  ICollection<Contract> bag = list;
  IList<Contract> byIndex = list;
  IReadOnlyList<Contract> read = list;
  // read.Clear(); does not compile

  Next questions, in Deep →Excellon Software: what is IEnumerable?
• InterviewerWhy does changing a list inside foreach throw?

  List<T> keeps a version number, and its enumerator (the small object a foreach uses to walk the list) records the version it started with. Add, Remove, Clear and even setting an item by index increase it, so the next MoveNext (the call that moves to the next item) sees a different collection and throws InvalidOperationException with "Collection was modified; enumeration operation may not execute." Setting an item by index throws too. The fix is to collect the items first and remove after the loop, or walk backwards with a for. RemoveAll after the loop is safe because it does not use the public enumerator.

  foreach (Contract c in contracts)
  {
    if (c.IsSettled)
      contracts.Remove(c); // throws
  }
   
  // safe: one pass, after the loop
  contracts.RemoveAll(c => c.IsSettled);

  Next questions, in Deep →Walk the incident →
• ReportedWhat is HashSet, and when do you use it instead of a List?

  A HashSet<T> is a set of unique items with fast membership. Add returns false when the item is already there, and Contains is O(1) on average because it hashes the value and checks one bucket. Use it when the question is "have I seen this?" or "is this allowed?", not when order matters; it promises no order. It uses the type's Equals and GetHashCode, so a class without them compares by reference.

  var vins = new HashSet<string>();
  vins.Add("VIN-1"); // true
  vins.Add("VIN-1"); // false
  bool open = vins.Contains("VIN-9");

  Next questions, in Deep →Solsynch Technologies: what is HashSet?

Follow-up tree

Answer, then open the next level. That is the order an interviewer digs in.

Reporteda candidate was asked Intervieweran interviewer asks it

• ReportedWhat is the difference between IEnumerable, ICollection and IList?

  They are a ladder of promises. IEnumerable<T> gives you foreach and nothing else. ICollection<T> adds Count, Add, Remove, Contains and Clear. IList<T> adds the indexer, Insert, RemoveAt and IndexOf. A List<T> implements all three, so the same object can be handed out through any of them; the interface you choose tells the caller what they are allowed to do.

  IEnumerable<Contract> loop = list;
  ICollection<Contract> bag = list;
  IList<Contract> byIndex = list;
  IReadOnlyList<Contract> read = list;
  // read.Clear(); does not compile

  Excellon Software: what is IEnumerable?
  • Why return IReadOnlyList instead of List?

    Because the return type is the caller's permission slip. List<T> says "you may add, remove and clear my list"; IReadOnlyList<T> says "read it". It does not copy the data, and AsReadOnly cannot be cast back to List<T>; a cast to IList<T> compiles, but Clear then throws at run time, so the guard still holds.

    Walk the bug →
  • Does IEnumerable mean the query runs once?

    No. An IEnumerable<T> can be a lazy query: the work happens when you loop, and a second foreach runs it again. If you need the items twice, put them in a list once with ToList and keep that list. A List<T> already holds its items; it does not re-run anything.

• InterviewerWhy does changing a list inside foreach throw?

  List<T> keeps a version number, and its enumerator (the small object a foreach uses to walk the list) records the version it started with. Add, Remove, Clear and even setting an item by index increase it, so the next MoveNext (the call that moves to the next item) sees a different collection and throws InvalidOperationException with "Collection was modified; enumeration operation may not execute." Setting an item by index throws too. The fix is to collect the items first and remove after the loop, or walk backwards with a for. RemoveAll after the loop is safe because it does not use the public enumerator.

  foreach (Contract c in contracts)
  {
    if (c.IsSettled)
      contracts.Remove(c); // throws
  }
   
  // safe: one pass, after the loop
  contracts.RemoveAll(c => c.IsSettled);

  Walk the incident →
  • Does every collection throw when it changes during foreach?

    No, and that is the trap. The check is per collection and per operation. A List<T> throws on add, remove and index-set. On .NET 10, a HashSet<T> threw on Add but not when I removed the current item, and a Dictionary did not throw on Remove. Never rely on the exception to protect you: do not change any collection while a foreach is walking it.

• ReportedWhat is HashSet, and when do you use it instead of a List?

  A HashSet<T> is a set of unique items with fast membership. Add returns false when the item is already there, and Contains is O(1) on average because it hashes the value and checks one bucket. Use it when the question is "have I seen this?" or "is this allowed?", not when order matters; it promises no order. It uses the type's Equals and GetHashCode, so a class without them compares by reference.

  var vins = new HashSet<string>();
  vins.Add("VIN-1"); // true
  vins.Add("VIN-1"); // false
  bool open = vins.Contains("VIN-9");

  Solsynch Technologies: what is HashSet?
  • Why did my HashSet keep two objects with the same value?

    Because the objects are different references and the class has no Equals or GetHashCode override. HashSet<T> uses the EqualityComparer<T> default (the object that decides whether two items are equal): reference equality for a class, value equality for a record or a type that overrides both. Key the set by the natural value (HashSet<string> of VINs), or make the type a record/override equality. In a quick test, the class set held two and the record set held one.

  • Can I change an item after adding it to a HashSet?

    Not a field used by GetHashCode. The set filed the object under the old hash; after the change the new hash points at another bucket, and Contains returns false even though the object is still inside; a quick test did exactly that. Treat keys in a set or dictionary as immutable (never change them after adding), or remove, change and re-add.

  • Is HashSet ordered?

    No order is promised. In a small test it may look like insertion order, because of how the buckets happen to fall, but that is an implementation detail. If order matters, keep a List<T> for the order and a HashSet<T> for the membership check.

• Array vs ArrayList vs List<T>: which is faster, and why?

  An array is the fastest and smallest for a fixed count: one block, O(1) index, no per-item object. List<T> adds a little overhead for the count and the growth strategy, but it is close, and it is type-safe with no boxing. ArrayList is the slowest of the three for value types: every int is boxed into an object on Add, and every read needs a cast. A quick test added 100,000 ints: ArrayList allocated about 4.5 megabytes, List<int> about 1 megabyte (its growing array only).

  • How does List<T> grow?

    It keeps an array and a count. A new list has capacity 0; the first Add makes capacity 4; when full, it doubles (8, 16, 32...) and copies the old items. Doubling makes Add amortised O(1), and Capacity is the array size, not the item count. A quick test showed capacity 4 after the first Add and 8 after the fifth.

    See the costs →
  • How do I get an array out of a List?

    ToArray copies the items into a new array. List<T> does not expose its internal array: it is private and may be longer than Count; ToArray gives a right-sized copy.

• When would you use a Dictionary instead of a HashSet?

  When each key carries a value. A Dictionary<TKey,TValue> gives O(1) average lookup and remembers one value per key; a HashSet<T> is the same structure with keys only. Add with an existing key throws, dict[key] = value overwrites, and TryGetValue is the safe read when a miss is normal, because it reports the miss without throwing. Both need stable GetHashCode/Equals and neither is thread-safe for writes.

  var contract = new Contract("VIN-1");
  var map = new Dictionary<string, Contract>();
  map["C-1042"] = contract;
  // out var c: filled when the key exists
  if (map.TryGetValue("C-9999", out var c))
  {
    Console.WriteLine(c.Vin);
  }

• Are List and Dictionary thread-safe?

  No. A List<T> or Dictionary can throw or corrupt its internal state when one thread writes while another reads. For shared writes use ConcurrentDictionary, a lock, or a collection designed for the job; for read-only sharing after construction, a list that is never changed is safe to read from many threads. The collection type does not make your own invariants thread-safe either: two Contains calls then Add need a lock around the pair.

• What does AsReadOnly actually stop?

  It returns a ReadOnlyCollection<T> wrapper: the caller cannot add, remove or clear through it, and cannot cast it back to List<T>. A cast to IList<T> compiles, but Add or Clear then throws NotSupportedException at run time. It is not a copy, so changes made through the original list are visible. If the caller must have a frozen snapshot, use ToList and return that as IReadOnlyList<T>; if they should see updates, AsReadOnly is the cheaper choice.

Production bugs, and how to tell them

Each one: what you see, why, the fix in code, and the line to say.

• The same contract was charged twice

  Navistar Financial dealer support ticket:
  "We were charged excess mileage twice for contract C-1042. The two rows are the same contract."
  (no exception, no error log)

  Cause

  The nightly charge run merged two feeds and used a HashSet<Charge> to drop repeated rows. Charge has no Equals or GetHashCode, so the set compared by reference: two Charge objects for C-1042 were two keys. Both passed Add, so both went to the ledger.

  Fix

  Key the set by the contract number, HashSet<string>, so the value decides. A test sends two Charge rows for C-1042 and asserts one ledger row. The contract number is the identity here: a VIN can have more than one contract over time, so a VIN is not safe for this dedupe.

  Charge.csBeforeAfter

  Diagram · step 1Two feeds send the same charge twice: two Charge objects for C-1042.Show diagram

  Charge runadds to a set

  Charge row 1C-1042

  Charge row 2C-1042

  1public class Charge2{3 public string ContractNumber4 { get; set; } = "";5}

  Charge.cs · line 1 · 1 of 3One excess-mileage row. Charge has no Equals or GetHashCode, so a set compares references.

  BackNext line

  Say it

  A set of a plain class compares by reference, so two charge rows for C-1042 were two keys and we charged twice. I keyed the set by the contract number, and a test proves one row. The number is the identity; a VIN can have more than one contract.

• Settled contracts stayed on the month-end report

  Navistar Financial month-end reconciliation:
  "The report shows 412 settled contracts and the balance is $1.9m too high."
  (no exception, no error log)

  Cause

  The cleanup used a for loop that moved forward and called lines.RemoveAt(i). Removing at i shifts the next line into that slot, then i++ steps past it. When two settled contracts were next to each other, the second was never checked and stayed on the report. No exception, because no foreach enumerator was involved.

  Fix

  Remove settled lines with lines.RemoveAll(l => l.IsSettled) after the read pass, or walk the list backwards. A test puts two settled contracts side by side and asserts none are left.

  ReportLine.csBeforeAfter

  Diagram · step 1The list is A (settled), B (settled), C (open). The loop starts at i = 0.Show diagram

  Remove loopi moves forward

  Report linesA, B, C

  1public class ReportLine2{3 public bool IsSettled4 { get; set; }5}

  ReportLine.cs · line 1 · 1 of 2One row on the month-end report.

  BackNext line

  Say it

  Removing by index while moving forward skips the item that shifts into the gap, so adjacent settled contracts survived. I use RemoveAll, and a test with two settled contracts in a row proves none are left.

Traps

• Don't sayArrayList is just an older List.SayNot the same: ArrayList stores object, boxes value types and needs casts. List<T> is type-safe and avoids the boxes. Use it for every new list.
• Don't sayIEnumerable has a Count.SayOnly ICollection and IReadOnlyCollection promise Count. On an IEnumerable, LINQ Count() may walk the whole sequence, or re-run the query, so put it in a list once with ToList if you need the number twice.
• Don't sayHashSet keeps insertion order.SayNo order is promised; a test that looks ordered is luck. Keep a List for order and a HashSet for fast membership when you need both.
• Don't sayList is fine for reads while another thread writes.SayIt is not: List and Dictionary are not thread-safe. Use a lock, a concurrent collection, or a copy per task.

Traps

What should you say instead? Tap to check.

• Don't sayArrayList is just an older List.

  Say instead

  Not the same: ArrayList stores object, boxes value types and needs casts. List<T> is type-safe and avoids the boxes. Use it for every new list.

• Don't sayIEnumerable has a Count.

  Say instead

  Only ICollection and IReadOnlyCollection promise Count. On an IEnumerable, LINQ Count() may walk the whole sequence, or re-run the query, so put it in a list once with ToList if you need the number twice.

• Don't sayHashSet keeps insertion order.

  Say instead

  No order is promised; a test that looks ordered is luck. Keep a List for order and a HashSet for fast membership when you need both.

• Don't sayList is fine for reads while another thread writes.

  Say instead

  It is not: List and Dictionary are not thread-safe. Use a lock, a concurrent collection, or a copy per task.