Collections & Arrays

An array is a fixed-size, zero-indexed, homogeneous collection. Even an int[] is a reference-type object living on the heap, holding elements of one element type. Its Length is set at creation and cannot change, and every index access is bounds-checked, throwing IndexOutOfRangeException past the end.

An Array has a fixed length and is strongly typed to one element type. ArrayList is resizable but stores every item as object, so value types get boxed on insert and reads need a downcast — costing performance and type safety. Modern code prefers List<T>, which is resizable yet generic, avoiding both boxing and casts.

IEnumerator is the cursor over a sequence: MoveNext() advances and returns whether an element exists, Current reads the element at the cursor, and Reset() rewinds. A collection implements IEnumerable, whose GetEnumerator() hands back a fresh enumerator. foreach is sugar that calls GetEnumerator(), loops on MoveNext(), and reads Current each pass.

Hashtable is non-generic: its keys and values are object, so value types box on insert and reads need casts, and it is loosely typed. Dictionary<TKey,TValue> is generic and type-safe, storing keys and values as their real types with no boxing. Both hash the key for average O(1) lookup; the generic one is the modern default.

Writing new { Name = x, Age = y } makes the compiler emit an unnamed, immutable type with read-only properties inferred from the initializer. Since it has no name you can hold it, it is usable only through var or type inference, never declared explicitly. Its main use is shaping intermediate results in LINQ projections.

A jagged array int[][] is an array of independent row arrays, so each row is a separate heap object and rows may differ in length. A rectangular array int[,] is a single contiguous block with fixed dimensions set at creation, where every row has the same length. Jagged trades extra indirection for ragged, per-row sizing.

List<T> wraps a backing array. Count is how many items it holds; Capacity is how many slots that array currently has. When you Add and Count reaches Capacity, it allocates a larger array — typically doubling — and copies the existing items over. Those copies are rare and spread across many adds, so Add is amortized O(1).

Array.Clone() allocates and returns a brand-new array, while CopyTo writes elements into an existing destination array you already own. Both perform a shallow copy: value-type elements are copied bit-for-bit, but reference-type elements only have their references copied, so source and copy share the very same objects.