Arrays and Lists
Arrays are the most fundamental collection type in .NET: a contiguous, fixed-size block of memory holding elements of a single type, declared as T[]. Once created with new int[5], an array's length can never change — you can overwrite its elements but not grow or shrink it. List<T>, found in System.Collections.Generic, wraps an internal array and adds dynamic resizing, exposing methods like Add, Remove, and Insert that automatically reallocate a larger backing array when capacity is exceeded. In practice, most application code reaches for List<T> by default and drops to raw arrays only when the size is truly fixed and known, or when working with performance-critical or interop code where the array's contiguous, allocation-free access patterns matter.
Cricket analogy: A fixed cricket XI of 11 named players is like new int[5] locked at that size, you can swap Kohli for Gill but never add a 12th player, while a full squad list resizes freely like List<T>.
Array declaration and multi-dimensional forms
C# supports single-dimensional arrays (int[] scores), rectangular multi-dimensional arrays (int[,] grid = new int[3,3], a single contiguous block), and jagged arrays (int[][] jagged, an array of arrays, where each row can have a different length and is a separate heap allocation). Rectangular arrays are generally faster for uniform grids because of better cache locality, while jagged arrays are more flexible and often faster when rows genuinely differ in length, since you avoid wasting memory on padding.
Cricket analogy: A single-dim array is like a batting order of 11 names; a rectangular array is a fixture grid of teams vs teams with uniform rows; a jagged array is each team's squad list where Mumbai Indians and Chennai Super Kings carry different squad sizes.
// Fixed-size array — length is baked in at creation time.
int[] scores = { 91, 85, 76, 99, 60 };
// List<T> — grows dynamically as items are added.
var leaderboard = new List<string>(capacity: 4) { "Ada", "Grace" };
leaderboard.Add("Linus");
leaderboard.Insert(0, "Margaret");
// Span<T> lets you slice an array without copying.
Span<int> topThree = scores.AsSpan(0, 3);
// Converting between the two.
List<int> scoreList = scores.ToList();
int[] backToArray = scoreList.ToArray();
foreach (var name in leaderboard)
{
Console.WriteLine(name);
}Performance characteristics
Both arrays and List<T> offer O(1) indexed access and are backed by contiguous memory, which makes iteration cache-friendly. List<T>.Add is amortized O(1): most calls just write into unused capacity, but when capacity is exhausted the list allocates a new backing array (typically doubling in size) and copies every existing element, an O(n) operation that happens infrequently. If you know the eventual size in advance, passing it to the List<T> constructor (new List<T>(capacity: 1000)) avoids repeated reallocation. Inserting or removing from the middle of either an array or a List<T> is O(n) because subsequent elements must shift.
Cricket analogy: Looking up the player at batting position 4 is O(1) like checking a scoreboard slot directly, but inserting a new batsman at position 3 means shifting everyone below down one, just like List<T>'s O(n) insert.
Arrays in C# implicitly implement IList<T>, ICollection<T>, and IEnumerable<T>, which is why you can pass an array anywhere those interfaces are expected. Unlike Java arrays, C# arrays are also covariant for reference types (an object[] reference can point to a string[]), which is convenient but can cause a runtime ArrayTypeMismatchException if you write an incompatible element into it through the covariant reference.
Arrays and value-type collections are frequently confused with reference semantics: assigning one array variable to another (int[] b = a;) copies the reference, not the elements — mutating b[0] also changes what a[0] sees, since both point to the same underlying array. Use Array.Copy, Clone() (shallow), or ToArray()/ToList() on a source sequence when you actually need an independent copy.
When to choose which
Prefer List<T> when the number of elements is unknown ahead of time or changes over the collection's lifetime — it is the pragmatic default for application-level code. Prefer a raw array when the size is fixed and known (e.g. a 3x3 tic-tac-toe board, RGB pixel bytes, or a lookup table), when interoperating with APIs that require arrays specifically, or in hot paths where avoiding List<T>'s slight indirection and capacity-management overhead matters. Span<T> and Memory<T> offer a further step for high-performance code, letting you work with slices of arrays without allocating new memory at all.
Cricket analogy: A T20 series with unknown overs due to rain calls for a flexible squad list like List<T>, while a fixed 3x3 practice net drill uses a locked array; Span<T> is like reviewing a highlight clip without recording a new video.
- Arrays (
T[]) have a fixed length set at creation;List<T>grows dynamically by reallocating its internal array. - Both offer O(1) indexed access via contiguous memory;
List<T>.Addis amortized O(1) but occasionally triggers an O(n) resize/copy. - Jagged arrays (
T[][]) allow rows of different lengths; rectangular arrays (T[,]) are one contiguous uniform block. - Assigning an array variable copies the reference, not the elements — use Clone()/ToArray() for an independent copy.
- Pre-sizing a List<T>'s capacity when the final count is known avoids repeated reallocation.
- Arrays implicitly implement IList<T>/ICollection<T>/IEnumerable<T>, so they interoperate seamlessly with LINQ and generic collection APIs.
Practice what you learned
1. What happens when a List<T>'s internal capacity is exceeded during an Add call?
2. What is the effect of `int[] b = a;` where `a` is an existing array?
3. What distinguishes a jagged array from a rectangular multi-dimensional array in C#?
4. Why might you pre-size a List<T> with `new List<T>(capacity: 1000)`?
5. Which interfaces do C# arrays implicitly implement?
Was this page helpful?
You May Also Like
Dictionaries and Sets
Learn how Dictionary<TKey,TValue> and HashSet<T> use hashing for near-constant-time lookups, and how to use them correctly with custom key types.
Collection Interfaces
Survey the layered hierarchy of IEnumerable, ICollection, IList, and their read-only and generic variants that unify how .NET collections are consumed.
Generics Explained
Understand how C# generics let you write type-safe, reusable code that works across many types without sacrificing performance or requiring casts.
LINQ Basics
Language Integrated Query lets you write expressive, type-safe queries directly in C# over collections, databases, and XML using a unified syntax.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics