Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
74 results across 1 active filter
Page 2 of 4
Distinguishes callable delegate values from publisher-controlled events and makes subscription lifetime explicit.
Explains how hash-based collections use hash codes and equality, then chooses Dictionary or HashSet from the value the program needs to store.
Uses controlled state transitions and intention-revealing APIs to keep objects valid rather than treating encapsulation as private fields alone.
Connects equality semantics to hash-based collections and chooses identity or value equality deliberately.
Preserves failure context, catches only where recovery or translation is possible, and uses filters without hiding unrelated faults.
Explain async/await as C# syntax over Task-based asynchronous work, with attention to non-blocking I/O and request throughput.
Explains static extension binding, instance-member precedence, namespace ambiguity, null receivers, and compatibility when APIs evolve.
Implements a stable first-unique-character search using counts and original order.
Flattens a tree into display paths while preserving order and preventing simple cycles.
Uses constraints to express required operations and explains safe assignment direction for generic producers and consumers.
Builds customer summaries from order rows using grouping, aggregation, and deterministic ordering.
Focuses on ToList chains, collection capacity, repeated enumeration, and memory-aware data shaping.
Introduces managed heap cleanup, generational collection, object lifetime, and why allocation behavior affects .NET services.
Describes lazy iterator execution, state-machine behavior, early termination, resource disposal, and repeat-enumeration consequences.
Compare synchronous enumeration with async streaming and explain when IAsyncEnumerable helps with large or delayed data.
Chooses immutable values and controlled mutable entities based on identity, concurrency, invariants, allocation cost, and update semantics.
Implements a small in-memory fixed-window rate limiter with per-key counters.
Implements a small LRU cache using a dictionary plus linked list for O(1) get and put.
Uses inheritance only for stable behavioral subtyping and tests whether derived objects preserve the promises callers rely on.
Balances declarative transformations with explicit control flow when allocation, early exit, mutation, diagnostics, or complex state matters.
Predicts when an in-memory LINQ pipeline runs and prevents repeated work, changed results, and hidden side effects.
Chooses when to keep a sequence lazy and when to create a stable collection with ToList, ToArray, or another deliberate materialization.
Implements interval merging for scheduling-style time ranges with sorted output.
Starts object-oriented design from cohesive state and behavior instead of creating classes for every noun in a requirement.