Why collections over arrays in C Sharp (C#) - Why It Works This Way

Overview - Why collections over arrays

What is it?

Collections and arrays are both ways to store groups of items in C#. Arrays have a fixed size, meaning once created, you cannot change how many items they hold. Collections, like lists or dictionaries, are more flexible and can grow or shrink as needed. They also provide many helpful features to manage data easily.

Why it matters

Using collections instead of arrays solves the problem of fixed size and limited functionality. Without collections, programmers would struggle to handle changing data sizes or perform common tasks like searching, sorting, or adding items efficiently. Collections make programs easier to write, read, and maintain, especially when data changes over time.

Where it fits

Before learning about collections, you should understand arrays and basic data storage. After mastering collections, you can explore advanced data structures like linked lists, trees, and hash tables, or learn about LINQ for powerful data queries.

Mental Model

Core Idea

Collections are flexible, feature-rich containers that manage groups of items dynamically, unlike fixed-size arrays.

Think of it like...

Think of an array like a row of fixed mailboxes where you can only put letters in a set number of boxes. Collections are like a flexible filing cabinet where you can add or remove drawers anytime and organize papers easily.

Fixed-size Array: [item1][item2][item3][item4]

Flexible Collection:
┌─────────────┐
│ item1      │
│ item2      │
│ item3      │
│ item4      │
│ item5      │  <-- can grow or shrink
└─────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Arrays Basics

Concept: Arrays store multiple items of the same type in a fixed-size sequence.

In C#, an array is declared with a fixed size, for example: int[] numbers = new int[3]; This array can hold exactly three integers. You access items by their position, starting at zero. Arrays are simple and fast but cannot change size after creation.

Result

You can store and access a fixed number of items efficiently.

Knowing arrays helps you understand the limitations that collections overcome.

2

Foundation

Limitations of Arrays

Concept: Arrays cannot grow or shrink, and lack many built-in features for managing data.

If you want to add a new item beyond the array size, you must create a new larger array and copy items over manually. Arrays also don't provide easy methods for searching, sorting, or removing items. This makes managing dynamic data cumbersome.

Result

You realize arrays are rigid and require extra work for common tasks.

Understanding these limits motivates the need for more flexible data structures.

3

Intermediate

Introducing Collections

Concept: Collections like List provide dynamic sizing and useful methods for data management.

A List can grow or shrink as you add or remove items. For example, List numbers = new List(); numbers.Add(5); numbers.Add(10); The list automatically resizes and offers methods like Remove, Contains, and Sort.

Result

You can easily manage groups of items without worrying about size limits.

Collections simplify coding by handling resizing and common operations internally.

4

Intermediate

Comparing Arrays and Collections

🤔Before reading on: do you think collections are always slower than arrays? Commit to your answer.

Concept: Collections add flexibility but may have slight performance differences compared to arrays.

Arrays are faster for fixed-size data because they have less overhead. Collections like List use arrays internally but resize and copy data when needed, which can cost time. However, collections save development time and reduce bugs by managing complexity.

Result

You understand the tradeoff between performance and flexibility.

Knowing when to use arrays or collections depends on your data needs and performance goals.

5

Advanced

Collections Provide Rich Interfaces

🤔Before reading on: do you think collections only add resizing or also add new ways to work with data? Commit to your answer.

Concept: Collections implement interfaces like IEnumerable and ICollection that enable powerful features like iteration and LINQ queries.

Because collections follow standard interfaces, you can use foreach loops, LINQ methods, and other tools seamlessly. Arrays also implement some interfaces but lack many collection-specific methods. This makes collections more versatile in real-world programming.

Result

You can write cleaner, more expressive code using collections.

Understanding interfaces behind collections unlocks advanced programming techniques.

6

Expert

Internal Mechanics of List<T> Resizing

🤔Before reading on: do you think List grows by adding one slot each time it needs more space? Commit to your answer.

Concept: List doubles its internal array size when capacity is exceeded to optimize performance.

When you add items beyond the current capacity, List creates a new internal array twice as large and copies existing items over. This reduces the number of times resizing happens, balancing memory use and speed. Understanding this helps optimize code that adds many items.

Result

You grasp how collections manage memory efficiently behind the scenes.

Knowing resizing strategies helps prevent performance pitfalls in large data operations.

Under the Hood

Collections like List use an internal array to store items. When the list grows beyond its current capacity, it allocates a new larger array (usually double the size), copies existing items to it, and discards the old array. This resizing is automatic and invisible to the programmer. Collections also implement interfaces that allow iteration, searching, and other operations efficiently.

Why designed this way?

Arrays were simple and fast but inflexible. Collections were designed to provide dynamic sizing and rich functionality while maintaining good performance. Doubling the size on resize is a tradeoff to minimize copying operations while not wasting too much memory. Interfaces standardize how collections behave, enabling reusable code and interoperability.

List<T> Internal Structure:

┌───────────────┐
│ List<T>      │
│ ┌───────────┐│
│ │ Array     ││
│ │ [item1]   ││
│ │ [item2]   ││
│ │ [item3]   ││
│ │ [empty]   ││  <-- capacity > count
│ └───────────┘│
└───────────────┘

When adding beyond capacity:

Old Array (size 4) -> New Array (size 8)
Copy items -> Add new item

Myth Busters - 3 Common Misconceptions

Quick: Do you think collections always use more memory than arrays? Commit to yes or no.

Common Belief: Collections always use more memory than arrays because they are more complex.

Reality: Collections may use slightly more memory due to extra features and resizing buffers, but they optimize memory use by resizing smartly and releasing unused space.

Why it matters: Assuming collections waste memory might lead developers to avoid them unnecessarily, causing more complex and error-prone code.

Quick: Do you think arrays and collections can be used interchangeably without any code changes? Commit to yes or no.

Common Belief: You can replace arrays with collections anywhere without changing code.

Reality: Arrays and collections have different APIs and behaviors; replacing one with the other often requires code changes, especially for adding or removing items.

Why it matters: Ignoring these differences can cause bugs or compilation errors when switching between arrays and collections.

Quick: Do you think List grows by adding one slot each time it needs more space? Commit to yes or no.

Common Belief: List increases its size by one each time you add an item beyond capacity.

Reality: List doubles its internal array size when resizing to reduce the number of costly copy operations.

Why it matters: Misunderstanding resizing can lead to inefficient code if you add many items one by one without pre-sizing.

Expert Zone

1

Collections implement interfaces like IReadOnlyCollection to provide read-only views, enabling safer code sharing.

2

Some collections, like LinkedList, optimize for frequent insertions/removals but have different performance tradeoffs than List.

3

Choosing the right collection depends on usage patterns; for example, Dictionary offers fast lookups but uses more memory.

When NOT to use

Avoid collections when you have a fixed-size dataset known at compile time and need maximum performance with minimal overhead; arrays are better here. For real-time or memory-critical systems, carefully consider collection overhead. Alternatives include Span for stack-based memory or custom data structures.

Production Patterns

In real-world C# applications, List is the most common collection for dynamic arrays. Developers often pre-size lists with a capacity to optimize performance. Collections are combined with LINQ for expressive data queries. Dictionaries and HashSets are used for fast lookups. Immutable collections are used in multi-threaded environments to avoid data races.

Connections

Dynamic Arrays (Data Structures)

Collections like List implement dynamic arrays, a common data structure concept.

Understanding dynamic arrays in computer science helps grasp how collections resize and manage memory efficiently.

Interfaces in Object-Oriented Programming

Collections implement standard interfaces to provide consistent behavior across types.

Knowing interfaces clarifies how collections can be used interchangeably and integrated with language features like foreach and LINQ.

Filing Systems in Office Management

Both collections and filing systems organize and manage groups of items flexibly.

Seeing collections as filing systems helps appreciate the importance of organization, easy access, and dynamic growth in managing data.

Common Pitfalls

#1 Trying to add items to an array beyond its fixed size.

Wrong approach:

int[] numbers = new int[2];
numbers[2] = 5; // Error: Index out of range

Correct approach:

List numbers = new List();
numbers.Add(5); // Works fine

Root cause:

Misunderstanding that arrays have fixed size and cannot grow dynamically.

#2 Assuming collections always perform slower than arrays and avoiding them.

Wrong approach:

Using arrays everywhere even when data size changes frequently, leading to complex resizing code.

Correct approach:

Use List for dynamic data to simplify code and maintain reasonable performance.

Root cause:

Overestimating performance cost of collections without considering development and maintenance benefits.

#3 Not pre-sizing a List when adding many items, causing multiple resizes.

Wrong approach:

List numbers = new List();
for(int i=0; i<10000; i++) numbers.Add(i);

Correct approach:

List numbers = new List(10000);
for(int i=0; i<10000; i++) numbers.Add(i);

Root cause:

Ignoring internal resizing behavior and its performance impact.

Key Takeaways

Arrays are fixed-size containers suitable for known, unchanging data sizes.

Collections provide dynamic sizing and rich methods to manage data easily and safely.

Understanding the tradeoffs between arrays and collections helps write efficient and maintainable code.

Collections implement interfaces that enable powerful language features like iteration and LINQ.

Knowing internal resizing strategies of collections helps optimize performance in large data scenarios.