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.
43 results across 1 active filter
Page 1 of 2
Uses reduction, thread-local state, atomic scalar updates, or indexed output instead of mutating a shared collection from parallel workers.
Clarify the common misconception that await starts work on a new thread, and explain what actually happens for I/O-bound operations.
Explains when cleanup needs asynchronous I/O, how await using guarantees disposal, and how ownership, exceptions, DI lifetimes, and shutdown affect the design.
Design background jobs that handle cancellation, retries, and duplicate execution without corrupting external state.
Use CancellationToken to stop wasted work when clients disconnect, timeouts expire, or background operations are being shut down.
Explain why CancellationTokenSource lifetime matters and how careless timeout creation can leak timers or resources.
Use Channel<T> to coordinate producer/consumer background processing inside a .NET service while respecting backpressure and shutdown.
Review async .NET code that does not accept or propagate CancellationToken and explain the practical production risk.
Choose between ConcurrentDictionary and explicit locks when managing concurrent in-memory data.
Explain what ConfigureAwait(false) does, why it mattered historically, and how to reason about it in ASP.NET Core and library code.
Sets concurrency from the constrained resource and verifies throughput, latency, and downstream safety instead of maximizing active work.
Serializes work for the same resource while preserving concurrency across independent keys and managing keyed-lock lifetime safely.
Decide how to handle CPU-heavy work in an API without damaging request throughput or making the system unreliable.
Explain why awaiting while holding synchronization resources can create deadlocks, contention, or stalled workflows.
Investigate a production API slowdown caused by blocking async calls, thread-pool pressure, and dependency waits.
Diagnoses thread-unsafe scoped dependencies inside parallel execution and redesigns the data boundary without exhausting shared resources.
Explain async/await as C# syntax over Task-based asynchronous work, with attention to non-blocking I/O and request throughput.
Explain why starting background work without awaiting or tracking it is risky in ASP.NET Core applications.
Explain how a .NET BackgroundService should handle cancellation, in-flight work, and application shutdown.
Defines what happens when several operations fail, cancellation arrives, or only part of a parallel batch completes, without orphaning work or hiding errors.
Explain how Task.WhenAll behaves when one or more tasks fail and how to inspect failures safely.
Compare synchronous enumeration with async streaming and explain when IAsyncEnumerable helps with large or delayed data.
Chooses between atomic operations and a critical section based on whether one value or a multi-step invariant must change safely.
Design a bounded-concurrency approach for calling an external API safely from .NET code.