Interview Q&A

Short answer: HashSet<T> is a generic collection that stores unique elements with no particular order. It is optimized for fast lookups, additions, and deletions. Use case: When you want to store a collection of unique items without duplicates, such as user IDs, tags, or keywords. HashSet<int> uniqueNumbers = new HashSet<int> { 1, 2, 3 }; uniqueNumbers.Add(4);

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: A Stack<T> is a generic collection in C# that stores elements in a Last-In, First-Out (LIFO) order. The last element added is the first one removed Belongs to System.Collections.Generic Real-world use case: Undo operations, browser history, expression evaluation.

Example code

Stack<int> numbers = new Stack<int>(); numbers.Push(10); numbers.Push(20); // Top of the stack

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: A Queue<T> is a generic collection in C# that stores elements in a First-In, First-Out (FIFO) order. The first item added is the first to be removed. It is part of the System.Collections.Generic namespace. Use case: Modeling real-world queues — e.g., print jobs, task scheduling, or customer service systems.

Example code

Queue<string> orders = new Queue<string>(); orders.Enqueue("Order1"); orders.Enqueue("Order2");

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: A Dictionary<TKey, TValue> is a generic collection in C# that stores data as key-value pairs. It provides fast lookup, addition, and removal of values based on their keys. Keys must be unique Keys must be non-null (for reference types) Values can be null if the type allows it

Example code

Dictionary<string, int> ages = new Dictionary<string, int>(); ages.Add("Alice", 30); ages.Add("Bob", 25); Use case: Storing user profiles by ID, or mapping product names to prices.

Real-world example (ShopNest)

ShopNest caches product prices in a Dictionary<string, decimal> keyed by SKU so checkout can look up a price in O(1) instead of scanning a list.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: List<T> is a generic collection in C# that represents a dynamically sized list of elements. It resides in the System.Collections.Generic namespace and grows or shrinks as needed. Use it when: You need a resizable array-like structure You want to perform frequent insertions, deletions, and searches

Example code

List<string> names = new List<string>(); names.Add("Alice");

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: List<string> fruits = new List<string> { "Apple", "Banana" }; foreach (var fruit in fruits) { Console.WriteLine(fruit); }

Example code

List<string> fruits = new List<string> { "Apple", "Banana" };
foreach (var fruit in fruits)
{ Console.WriteLine(fruit); }

Real-world example (ShopNest)

In ShopNest checkout, choose the collection by need: List for ordered cart lines, Dictionary for fast SKU lookup, HashSet for unique tags.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Generic collections are type-safe and defined using generics (<T>), allowing you to specify the type of elements they hold.

Explain a bit more

This ensures compile-time type checking and eliminates the need for casting. Non-generic collections, on the other hand, store elements as objects (object type), requiring boxing/unboxing for value types and casting for reference types. Example: // Generic collection List<int> numbers = new List<int>(); numbers.Add(10); // No boxing, type-safe // Non-generic collection ArrayList list = new ArrayList(); int value = (int)list[0]; // Needs casting Real-world use case: In applications dealing with specific data types (e.g., a list of customer IDs), generic collections are ideal. Non-generic collections may be used in legacy systems or when dealing with multiple data types.

Example code

list.Add(10); // Boxing occurs

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Internally, Queue<T> uses a circular array to efficiently manage memory and operations. Head pointer marks the front (next item to be dequeued). Tail pointer marks where the next item will be enqueued. Automatically resizes when capacity is exceeded. This implementation ensures constant time operations for enqueue and dequeue.

Real-world example (ShopNest)

ShopNest uses a Queue<Order> for “orders waiting for payment confirmation,” and a Stack<Uri> for back-navigation in the admin UI.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Collection<T> is a base class for creating custom collections. It wraps an IList<T> internally and provides virtual methods for insert, remove, and clear, allowing easy customization. Unlike List<T>, which is optimized for performance, Collection<T> focuses on extensibility. Useful when you want to create a collection with customized behaviors (e.g., validation, event firing).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: List<T> uses a contiguous array internally, so memory is compact and cache-friendly. LinkedList<T> stores elements in nodes with extra pointers (Next and Previous), leading to more memory overhead. Therefore, List<T> generally has lower memory usage and better cache performance than LinkedList<T>, especially for large collections.

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Feature ConcurrentQueue<T> Queue<T> Thread safety Designed for concurrent access Not thread-safe; requires locks Locking mechanism Internal lock-free or fine-grained locking No internal synchronization Suitable for Multi-threaded producer-consumer patterns Single-threaded scenarios or external synchronization ConcurrentQueue<T> allows safe enqueueing and dequeueing by multiple threads simultaneously without…

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: LINQ itself doesn’t modify collections directly but produces new collections based on queries. You typically combine LINQ with collection methods to add elements, for example: var evenNumbers = new List<int> { 2, 4, 6 };

Example code

var allNumbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var combined = allNumbers.Where(n => n % 2 == 0).ToList(); // Filters even numbers If you want to add LINQ results to a collection:
List<int> filteredNumbers = allNumbers.Where(n => n % 2 == 0).ToList();

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Feature SortedSet<T> HashSet<T> Ordering Maintains sorted order No guaranteed order Implementation Balanced binary search tree Hash table Lookup complexity O(log n) O(1) average Memory overhead Higher (tree nodes) Lower (hash buckets) Use case When sorted data or range queries needed Fast insertion and lookup without ordering

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Feature SortedList<TKey, TValue> Dictionary<TKey, TValue> Order Maintains keys in sorted order No guaranteed order Internal storage Uses two arrays (keys & values) Uses a hash table Lookup complexity O(log n) (binary search) O(1) average Insertion complexity O(n) (due to shifting elements) O(1) average Memory overhead Lower (arrays) Higher (hash buckets, overhead)

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Use AddFirst(value) to add at the start. Use AddLast(value) to add at the end. numbers.AddFirst(5); // Adds 5 at the beginning numbers.AddLast(30); // Adds 30 at the end

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Feature HashSet<T> List<T> Dictionary<TKey, TValue> Allows duplicates? No Yes Keys: No; Values: Yes Order No guaranteed order Maintains insertion order No guaranteed order Lookup speed O(1) average O(n) O(1) average for keys Key-value pairs No (only values) No Yes (key-value pairs)

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Internally, Stack<T> uses an array-based dynamic storage system: When capacity is exceeded, the internal array resizes automatically (typically doubles) The top of the stack is managed with a private index pointer This structure provides fast push and pop operations (constant time on average).

Real-world example (ShopNest)

ShopNest uses a Queue<Order> for “orders waiting for payment confirmation,” and a Stack<Uri> for back-navigation in the admin UI.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Internally, Queue<T> uses a circular array to efficiently manage memory and operations. Head pointer marks the front (next item to be dequeued).

Real-world example (ShopNest)

ShopNest uses a Queue<Order> for “orders waiting for payment confirmation,” and a Stack<Uri> for back-navigation in the admin UI.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Use the Add() method or the indexer []: // Using Add() dictionary.Add("key1", "value1"); // Using indexer dictionary["key2"] = "value2"; Note: Add() throws an exception if the key already exists, while indexer will overwrite the value.

Real-world example (ShopNest)

ShopNest caches product prices in a Dictionary<string, decimal> keyed by SKU so checkout can look up a price in O(1) instead of scanning a list.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: You can use the Add() or AddRange() method.

Example code

List<int> numbers = new List<int>(); numbers.Add(10); // Add single item numbers.AddRange(new int[] { 20, 30 }); // Add multiple

Real-world example (ShopNest)

In ShopNest, an order page loads products with List<Product> so you can Add items to the cart and access them by index. Use IEnumerable<T> when you only need to loop (for example, printing invoice lines).

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: for (int i = 0; i < fruits.Count; i++) { Console.WriteLine(fruits[i]); }

Example code

for (int i = 0; i < fruits.Count; i++)
{ Console.WriteLine(fruits[i]); }

Real-world example (ShopNest)

In ShopNest checkout, choose the collection by need: List for ordered cart lines, Dictionary for fast SKU lookup, HashSet for unique tags.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Generic collections offer several advantages: Type Safety: Compile-time checking prevents runtime errors. Performance: Avoids boxing/unboxing of value types. Code Clarity: Cleaner code without explicit casting. Reusability: Generic code can work with any data type.

Example code

List<string> names = new List<string>(); names.Add("Alice"); // Valid // names.Add(123); // Compile-time error Real-world use case: When managing a list of product names or order numbers, using List<string> or List<int> ensures that invalid data types are caught at compile time.

Real-world example (ShopNest)

Prefer List<Order> over ArrayList in ShopNest. Generics catch type mistakes at compile time and avoid boxing when you store ints or decimals.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: IComparer<T> defines a method Compare(T x, T y) for custom sorting logic (used in sorting operations like Sort()). IEqualityComparer<T> defines methods Equals(T x, T y) and GetHashCode(T obj) to determine equality and hashing (used in dictionaries, sets, etc.). They allow collections to customize how items are compared or checked for equality, beyond default implementations.

Real-world example (ShopNest)

In ShopNest checkout, choose the collection by need: List for ordered cart lines, Dictionary for fast SKU lookup, HashSet for unique tags.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Scenario Best Choice Trade-offs Fast indexed access List<T> Slower inserts/removes in the middle Frequent insert/delete at ends LinkedList<T> No fast indexed access; higher memory use Fast lookups by key Dictionary<TKey, TValue> No sorted order Sorted key-value pairs SortedList<TKey, TValue> or SortedDictionary<TKey, TValue> Slower inserts vs Dictionary Thread-safe multi-thread use ConcurrentDictionary /…

Explain a bit more

ConcurrentQueue Slight overhead for synchronization

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Use thread-safe collections provided by .NET (ConcurrentDictionary, ConcurrentQueue, BlockingCollection, etc.). Use synchronization primitives like lock, Mutex, Semaphore, or ReaderWriterLock around critical sections when using non-thread-safe collections. Avoid shared mutable state or design the program to minimize contention. Use immutable collections when possible to eliminate synchronization.

Real-world example (ShopNest)

In ShopNest checkout, choose the collection by need: List for ordered cart lines, Dictionary for fast SKU lookup, HashSet for unique tags.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.