Dynamic Array Management

In C#, raw arrays (string[]) are fixed in size and difficult to manage. Modern applications rely on the Generic Collections found in System.Collections.Generic. Choosing the right collection can mean the difference between an app that is "O(1) Instant" and an app that is "O(n) Sluggish."

1. List<T>: The Swiss Army Knife

The List is the go-to collection. It is essentially a dynamic array that automatically resizes itself. However, searching for an item in a list requires scanning every single element one by one (O(n)).

var names = new List<string> { "Sandeep", "Ankit" };
names.Add("John"); // O(1) mostly
bool exists = names.Contains("Sandeep"); // O(n) - Slow for 1 Million items!

2. Dictionary<TKey, TValue>: The Speed Demon

A Dictionary uses a Hash Table. It allows you to look up any value using a key almost instantly (O(1)), regardless of whether you have 10 items or 10 Million items.

var userCache = new Dictionary<int, User>();
userCache.Add(1, new User { Name = "Sandeep" });

// Instant lookup! No scanning required.
var user = userCache[1]; 

3. HashSet<T>: The Filter

A HashSet is like a Dictionary but only stores unique keys. It is the best way to handle "Distinct" lists or perform high-speed existence checks without the overhead of key/value pairs.

4. Interview Mastery

Q: "Why should we specify a 'Capacity' when initializing a new List or Dictionary if we already know the expected size?"

Architect Answer: "Memory Fragmentation and CPU cycles. When a `List` fills up, the CLR has to allocate a brand-new, larger array on the heap, copy all existing items to the new array, and mark the old array for Garbage Collection. This causes 'GC Pressure' and pauses your application. By passing a capacity—`new List(10000)`—you tell the CLR to allocate that memory block once upfront. This eliminates resizing operations entirely, providing a significant performance boost in high-frequency data processing."