C# Programming - MCQ Practice Questions

List<T> is generic and type-safe, preventing boxing/unboxing overhead and providing compile-time type checking. ArrayList stores objects and requires casting.

List<T> allows duplicates as it stores elements sequentially. Dictionary and Hashtable enforce unique keys; attempting to add a duplicate key throws an exception.

Count returns the number of elements currently stored. Capacity is different and refers to allocated space.

Stack<T> follows LIFO where the last element added is the first to be removed. Queue<T> follows FIFO (First In First Out).

The list initially has 3 elements. After Add(4), it has 4 elements. Count returns 4.

Clear() removes all elements from a collection. Remove() removes a specific element, and RemoveAt() removes an element at a specific index.

List<T> is backed by an array, allowing direct index-based access in constant time O(1).

Dictionary<K,V> in .NET maintains insertion order (in recent versions) and provides O(1) lookup. SortedDictionary maintains sorted order instead.

Accessing an invalid index throws IndexOutOfRangeException. This is a runtime error that must be caught to prevent program crashes.

IEnumerable interface provides GetEnumerator() method, enabling foreach iteration. IEnumerable<T> is the generic version.

Push() adds an element to the stack, while Pop() removes and returns the top element. If stack is empty, Pop throws InvalidOperationException.

Dictionary enforces unique keys. Attempting to add a duplicate key throws ArgumentException. Use dict["a"] = 2 to update.

SortedDictionary<K,V> automatically maintains keys in sorted order. Dictionary<K,V> maintains insertion order but not sorted order.

Both FindAll() and Where() (LINQ) can filter collections. Where() returns IEnumerable and is more modern. FindAll() returns a List directly.

HashSet<T> requires O(n) space to store n unique elements. Hash tables require linear space proportional to the number of stored elements.

OrderByDescending sorts by Age in descending order. ThenBy applies secondary sort by Name in ascending order. This is a multi-level LINQ sort.

IEnumerable<T> only provides iteration. ICollection<T> extends it with Count property and methods like Add(), Remove(), Clear() for modification.

ConcurrentDictionary<K,V> from System.Collections.Concurrent is thread-safe for multi-threaded applications, unlike Dictionary<K,V>.

List<T> maintains insertion order and allows duplicates. HashSet<T> doesn't allow duplicates, SortedSet<T> sorts elements, and Queue<T> follows FIFO.

Dequeue() throws InvalidOperationException on empty queue. TryDequeue() returns false instead. Peek() also throws but doesn't remove.