Interview Q&A

Short answer: LinkedList<T> is a doubly linked list collection in C#. It stores elements as nodes, where each node contains the data and references to the previous and next nodes. Allows efficient insertions and deletions anywhere in the list. Does not support indexed access like List<T>.

Example code

LinkedList<int> numbers = new LinkedList<int>(); numbers.AddLast(10); numbers.AddLast(20);

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: ConcurrentDictionary<TKey, TValue> is a thread-safe dictionary designed for concurrent access by multiple threads without needing external synchronization (locks). Supports atomic operations like adding, updating, and removing items. Useful in multi-threaded scenarios where data integrity and performance are critical.

Example code

ConcurrentDictionary<int, string> concurrentDict = new ConcurrentDictionary<int, string>(); concurrentDict.TryAdd(1, "One"); concurrentDict.TryUpdate(1, "Uno", "One");

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: SortedSet<T> is a collection that stores unique elements in sorted order. Implements a self-balancing binary search tree (usually a Red-Black Tree). Automatically maintains elements in ascending sorted order. Provides set operations like union, intersection, and difference.

Example code

SortedSet<int> sortedSet = new SortedSet<int> { 5, 1, 3 }; sortedSet.Add(2); // Sorted order maintained: {1, 2, 3, 5}

Real-world example (ShopNest)

When applying a coupon, ShopNest keeps used coupon codes in a HashSet<string> so “already used?” checks stay fast and unique.

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: SortedList<TKey, TValue> is a collection of key-value pairs that maintains the elements sorted by keys. Implements both IDictionary<TKey, TValue> and IList<KeyValuePair<TKey, TValue>>. Keys are automatically sorted in ascending order based on their natural comparer or a provided comparer.

Example code

SortedList<int, string> sortedList = new SortedList<int, string>(); sortedList.Add(3, "Three"); sortedList.Add(1, "One"); sortedList.Add(2, "Two"); The elements are stored sorted by key: 1, 2, 3.

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: LinkedList<T> is a doubly linked list collection in C#.

Explain a bit more

It stores elements as nodes, where each node contains the data and references to the previous and next nodes.

Example code

LinkedList<int> numbers = new LinkedList<int>(); numbers.AddLast(10); numbers.AddLast(20);

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: 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: 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: 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: 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: All these operations generally have O(1) average time complexity due to the underlying hash table structure.

Real-world example (ShopNest)

When applying a coupon, ShopNest keeps used coupon codes in a HashSet<string> so “already used?” checks stay fast and unique.

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: IEnumerable<T> is the base interface for all generic collections that can be enumerated (looped over). It allows the use of foreach loops and LINQ queries. It defines a single method: IEnumerator<T> GetEnumerator(); Example: List<string> items = new List<string> { "A", "B", "C" };

Example code

foreach (string item in items) // IEnumerable<string> in action
{ Console.WriteLine(item); } Real-world use case: When reading product data from a list or querying a database, IEnumerable<T> allows deferred execution and efficient data processing using LINQ.

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 BlockingCollection<T> Collection<T> Thread safety Thread-safe for adding and taking items Not thread-safe Blocking behavior Supports blocking and bounding (waits when empty/full) No blocking behavior Use case Producer-consumer scenarios General-purpose collection Additional features Supports bounded capacity and cancellation Basic collection BlockingCollection<T> wraps around other thread-safe collections…

Explain a bit more

and provides blocking and bounding capabilities, ideal for producer-consumer queues. 📘 C# Collections: Performance & Memory Considerations – Interview Q&A

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: Concise and readable code: LINQ makes querying collections clear and expressive. Declarative style: You focus on what to retrieve, not how. Powerful operations: Filtering, sorting, grouping, joining, projecting, and more. Deferred execution: Queries execute only when results are needed, improving performance. Strongly typed: Compile-time checking and IntelliSense support.

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: Searching by key uses binary search, so the time complexity is O(log n).

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: Push() → O(1) average, O(n) worst-case (if resizing needed) Pop() → O(1) These operations are fast and efficient due to the internal array structure.

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: Enqueue() → O(1) average case Dequeue() → O(1) average case Due to the internal circular array and pointer arithmetic, both operations are highly efficient unless resizing is needed (which is O(n), but infrequent).

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: Accessing an element by index is O(1) (constant time) — same as arrays. Example: int first = numbers[0]; // O(1)

Example code

Accessing an element by index is O(1) (constant time) — same as arrays. Example: int first = numbers[0]; // O(1)

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: Adding or removing at the start or end: O(1) Adding or removing at an arbitrary position (if you already have the node reference): O(1) Searching for a node by value: O(n), because traversal is required

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: The average time complexity is O(1) (constant time), thanks to hash-based indexing. However, in worst-case scenarios (rare), it can degrade to O(n).

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: double Calculate(double a, double b, char op)

Example code

{
return op switch
{ '+' => a + b, Follow on: '-' => a - b, '*' => a * b, '/' => b != 0 ? a / b : throw new DivideByZeroException(), _ => throw new ArgumentException("Invalid operator"), }; } Explanation: Simple switch statement performing basic arithmetic, with divide-by-zero check.

Real-world example (ShopNest)

In coding rounds, state complexity aloud, write a clear ShopNest-flavored example (orders, carts), then handle edge cases (empty list, null, overflow).

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 / b : throw new DivideByZeroException(), _ => throw new ArgumentException("Invalid operator"), Explanation: Simple switch statement performing basic arithmetic, with divide-by-zero check.

Explain a bit more

a / b : throw new DivideByZeroException(), _ => throw new ArgumentException("Invalid operator"), Explanation: Simple switch statement performing basic arithmetic, with divide-by-zero check. a / b : throw new DivideByZeroException(), _ => throw new ArgumentException("Invalid operator"), Explanation: Simple switch statement performing basic arithmetic, with divide-by-zero check.

Real-world example (ShopNest)

In coding rounds, state complexity aloud, write a clear ShopNest-flavored example (orders, carts), then handle edge cases (empty list, null, overflow).

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.