Interview Q&A

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);

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:

Stack<int> numbers = new Stack<int>();

numbers.Push(10);

numbers.Push(20); // Top of the stack

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:

Queue<string> orders = new Queue<string>();

orders.Enqueue("Order1");

orders.Enqueue("Order2");

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:

Dictionary<string, int> ages = new Dictionary<string, int>();

ges.Add("Alice", 30);

ges.Add("Bob", 25);

Use case: Storing user profiles by ID, or mapping product names to prices.

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:

List<string> names = new List<string>();

names.Add("Alice");

Answer: List&lt;string&gt; fruits = new List&lt;string&gt; { "Apple", "Banana" }; foreach (var fruit in fruits) { Console.WriteLine(fruit); }

What interviewers expect

• A clear definition tied to Collections in C# Collections projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Collections application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Collections architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Generic collections are type-safe and defined using generics (<T>), allowing you to specify

the type of elements they hold. 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

rrayList list = new ArrayList();
list.Add(10); // Boxing occurs
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.

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.

• 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).

• 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.

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 corrupting the data.

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 };
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();

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

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)

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

What interviewers expect

• A clear definition tied to Collections in C# Collections projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Collections application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Collections architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Feature HashSet<T> List<T> Dictionary<TKey,

TValue>

llows

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)

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).

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.

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.

What interviewers expect

• A clear definition tied to Collections in C# Collections projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Collections application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Collections architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: You can use the Add() or AddRange() method. Example: List&lt;int&gt; numbers = new List&lt;int&gt;(); numbers.Add(10); // Add single item numbers.AddRange(new int[] { 20, 30 }); // Add multiple

What interviewers expect

• A clear definition tied to Collections in C# Collections projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Collections application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Collections architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

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

What interviewers expect

• A clear definition tied to Collections in C# Collections projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Collections application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Collections architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

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:

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.

• 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.

Scenario Best Choice Trade-offs

Fast indexed

ccess

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 /

ConcurrentQueue

Slight overhead for

synchronization

• 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.