Why collections over arrays in C Sharp (C#) - Visual Breakdown

Concept Flow - Why collections over arrays

Start with Array

↓

Fixed Size - Cannot Resize

↓

Limited Flexibility

↓

Switch to Collection

↓

Dynamic Size - Can Add/Remove

↓

More Features - Sorting, Searching

↓

Better for Real-World Use

Arrays have fixed size and limited features, collections can grow and offer more tools, making them better for many tasks.

Execution Sample

C Sharp (C#)

int[] numbers = new int[3] {1, 2, 3};
// numbers size fixed

List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
list.Add(4); // works fine

Shows fixed size array vs dynamic List that can grow by adding items.

Execution Table

Step	Action	Array State	List State	Notes
1	Create array with 3 elements	[1, 2, 3]	[]	Array fixed size 3
2	Create empty list	[1, 2, 3]	[]	List starts empty
3	Add 1 to list	[1, 2, 3]	[1]	List size grows to 1
4	Add 2 to list	[1, 2, 3]	[1, 2]	List size grows to 2
5	Add 3 to list	[1, 2, 3]	[1, 2, 3]	List size grows to 3
6	Add 4 to list	[1, 2, 3]	[1, 2, 3, 4]	List size grows to 4, array cannot do this
7	Try to add 4 to array (not possible)	[1, 2, 3]	[1, 2, 3, 4]	Array size fixed, cannot add element

💡 Array size fixed at creation, list can grow dynamically as items are added.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	Final
numbers (array)	null	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
list (List<int>)	null	[1]	[1, 2]	[1, 2, 3]	[1, 2, 3, 4]	[1, 2, 3, 4]

Key Moments - 3 Insights

Why can't we add more elements to an array after creating it?

Arrays have a fixed size set when created, so adding elements beyond that size is not allowed, as shown in execution_table step 7.

How does a List allow adding more elements dynamically?

List manages its size internally and can resize its storage automatically when adding elements, as seen in execution_table steps 3 to 6.

Is the array content changed when we add elements to the List?

No, the array and List are separate; adding to the List does not affect the array, shown by their states in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the List state after step 5?

A [1, 2]

B [1, 2, 3, 4]

C [1, 2, 3]

D []

💡 Hint

Check the 'List State' column at step 5 in the execution_table.

At which step does the List first have more elements than the array?

A Step 6

B Step 5

C Step 4

D Never

💡 Hint

Compare 'Array State' and 'List State' columns in execution_table rows.

If we tried to add an element to the array after creation, what would happen?

A Array size increases automatically

B Error or not allowed

C Element replaces last item

D Array converts to List

💡 Hint

Refer to the note in execution_table step 7 about array size.

Concept Snapshot

Arrays have fixed size set at creation.
Collections like List can grow and shrink dynamically.
Lists provide useful methods like Add, Remove, Sort.
Use collections for flexible, real-world data handling.
Arrays are simple but limited in size and features.

Full Transcript

Arrays in C# have a fixed size that cannot be changed after creation. This means you cannot add or remove elements once the array is made. Collections, such as List<T>, are dynamic and can grow or shrink as needed. They provide helpful methods like Add and Remove to manage elements easily. The example code shows an array of size 3 and a List that starts empty and grows as elements are added. The execution table traces these changes step-by-step, showing the array remains the same while the List grows. This makes collections better for many real-world programming tasks where data size changes over time.

Practice

1. Why might you choose a collection like List<T> over an array in C#?

easy

A. Because collections can change size dynamically while arrays have fixed size.

B. Because arrays have more built-in methods than collections.

C. Because collections use less memory than arrays.

D. Because arrays can store different data types in the same array.

Solution

1. Step 1: Understand array size behavior

   Arrays in C# have a fixed size once created and cannot grow or shrink.

2. Step 2: Understand collection size behavior

   Collections like List<T> can dynamically add or remove items, changing their size.

3. Final Answer:

   Because collections can change size dynamically while arrays have fixed size. -> Option A

4. Quick Check:

   Collections grow/shrink; arrays fixed size [OK]

Hint: Remember: arrays fixed size, collections flexible size [OK]

Common Mistakes:

• Thinking arrays can resize automatically
• Believing collections use less memory always
• Confusing data type storage capabilities

2. Which of the following is the correct way to declare a collection that can grow in size in C#?

easy

A. int[] numbers = new int[5];

B. List<int> numbers = new List<int>();

C. int numbers = new List<int>();

D. ArrayList numbers = new int[5];

Solution

1. Step 1: Check syntax for array declaration

   int[] numbers = new int[5]; declares a fixed-size array, not a collection.

2. Step 2: Check syntax for collection declaration

   List<int> numbers = new List<int>(); correctly declares a generic list collection that can grow.

3. Final Answer:

   List<int> numbers = new List<int>(); -> Option B

4. Quick Check:

   List<T> syntax is for growable collections [OK]

Hint: Use List<T> for growable collections, arrays need size upfront [OK]

Common Mistakes:

• Using array syntax when collection is needed
• Assigning wrong types to variables
• Confusing ArrayList with arrays

3. What will be the output of this C# code?

List<int> nums = new List<int>() {1, 2, 3};
nums.Add(4);
Console.WriteLine(nums.Count);

medium

A. Compilation error

B. 3

C. 0

D. 4

Solution

1. Step 1: Understand initial list size

   The list nums starts with 3 elements: 1, 2, 3.

2. Step 2: Analyze the Add method effect

   Calling nums.Add(4); adds one more element, increasing count to 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   List.Count reflects added elements [OK]

Hint: Add increases collection size; Count shows current size [OK]

Common Mistakes:

• Assuming Count stays 3 after Add
• Confusing Count with capacity
• Expecting compilation error due to Add

4. Identify the error in this code snippet:

int[] arr = new int[3];
arr.Add(5);

medium

A. Array size must be declared as 5.

B. int[] cannot store integers.

C. Arrays do not have an Add method.

D. The array must be initialized with values.

Solution

1. Step 1: Check array methods

   Arrays in C# do not have an Add method; this method belongs to collections like List.

2. Step 2: Understand array limitations

   Arrays have fixed size and cannot add elements dynamically.

3. Final Answer:

   Arrays do not have an Add method. -> Option C

4. Quick Check:

   Arrays lack Add method [OK]

Hint: Arrays fixed size, no Add method; use List for adding [OK]

Common Mistakes:

• Trying to add elements to arrays
• Confusing array size with element count
• Assuming arrays have collection methods

5. You need to store a list of user names that can change during program execution. Which approach is best and why?

hard

A. Use a List<string> because it can grow and shrink as users are added or removed.

B. Use an array because it is faster and fixed size is enough.

C. Use a fixed-size array and recreate it every time the list changes.

D. Use a string variable to store all names separated by commas.

Solution

1. Step 1: Analyze data size flexibility needs

   User names list changes size, so fixed size arrays are inconvenient.

2. Step 2: Choose collection type for dynamic data

   List<string> allows adding/removing names easily without recreating the structure.

3. Final Answer:

   Use a List<string> because it can grow and shrink as users are added or removed. -> Option A

4. Quick Check:

   Dynamic data needs collections like List [OK]

Hint: Dynamic data? Use List<T> for easy resizing [OK]

Common Mistakes:

• Choosing fixed arrays for changing data
• Using strings to store multiple values unsafely
• Recreating arrays repeatedly instead of collections