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 2 of 2
Proves parallel speedup against a sequential baseline while accounting for overhead, saturation, tail latency, resource contention, and downstream impact.
Compare Parallel.ForEachAsync and Task.WhenAll for processing collections with async work and controlled concurrency.
Chooses a parallel API based on whether the workload is a data query or an imperative loop and keeps CPU work pure, bounded, and measurable.
Finds circular lock acquisition and replaces timing-dependent nested locking with a stable order or a simpler ownership boundary.
Combines ThreadPool counters, repeated stack snapshots, and wait-event traces to distinguish blocked workers from CPU or dependency pressure.
Investigate and fix a race condition caused by shared mutable state in a .NET service.
Investigate deadlocks or starvation caused by blocking on async code with Result, Wait, or GetAwaiter().GetResult().
Explain when Task.Run is useful, when async/await is enough, and why Task.Run is usually wrong for I/O in ASP.NET Core.
Compare Task and Thread in .NET, including abstraction level, scheduling, and when direct thread management is rarely appropriate.
Diagnose thread-pool starvation caused by blocking work, unbounded concurrency, or sync-over-async in .NET APIs.
Uses runtime-supported initialization rather than timing-dependent manual checks and defines failure, retry, and disposal behavior explicitly.
Distinguish timeouts from cancellation and explain how to combine them around external calls and request handling.
Redesigns read-heavy shared state so readers observe a complete version without coordinating every access through a lock.
Use SemaphoreSlim to bound concurrent asynchronous work without blocking threads unnecessarily.
Use Task.WhenAll to run independent asynchronous I/O operations concurrently while handling exceptions, cancellation, and dependency limits.
Explain the async state machine, continuation scheduling, and exception flow when a C# method awaits a Task.
Evaluates whether read-heavy access justifies a reader/writer lock instead of a simpler lock or immutable snapshot.
Explain why async void is usually dangerous outside event handlers and how exceptions behave differently.
Separates memory visibility and ordering from atomic multi-step updates, avoiding volatile as a substitute for real synchronization.