Skip to content

Tracks Drills Topics Technologies Tech stacks Skill areas

Tracks Drills Topics

Loading

Aporeon

Technical interview practice, from one developer to another.

About Privacy Terms

Drills

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.

Search

Track

Practice style

Level

More filters1

Topic

Technology

Tech stack

Skill area

16 results across 1 active filter

Page 1 of 1

Concept questionHard~9 min

Aggregate results from parallel work safely

Uses reduction, thread-local state, atomic scalar updates, or indexed output instead of mutating a shared collection from parallel workers.

Architecture scenarioHard~12 min

Channel<T> for background processing in .NET

Use Channel<T> to coordinate producer/consumer background processing inside a .NET service while respecting backpressure and shutdown.

.NETASP.NET CoreC#

Practice drill

Comparison questionMedium~7 min

ConcurrentDictionary vs lock

Choose between ConcurrentDictionary and explicit locks when managing concurrent in-memory data.

.NETASP.NET CoreC#

Architecture scenarioHard~12 min

Coordinate concurrent operations with per-key locking

Serializes work for the same resource while preserving concurrency across independent keys and managing keyed-lock lifetime safely.

.NETASP.NET CoreC#

Debugging scenarioHard~12 min

Deadlock risk from locking and awaiting

Explain why awaiting while holding synchronization resources can create deadlocks, contention, or stalled workflows.

.NETASP.NET CoreC#

Debugging scenarioHard~12 min

Do not share DbContext across parallel work

Diagnoses thread-unsafe scoped dependencies inside parallel execution and redesigns the data boundary without exhausting shared resources.

.NETASP.NET CoreC#

Comparison questionMedium~7 min

Interlocked vs lock for atomic state changes

Chooses between atomic operations and a critical section based on whether one value or a multi-step invariant must change safely.

Architecture scenarioMedium~10 min

Limit concurrency for external API calls

Design a bounded-concurrency approach for calling an external API safely from .NET code.

.NETASP.NET CoreC#

Comparison questionMedium~7 min

lock vs SemaphoreSlim in C#

Compare lock and SemaphoreSlim for protecting shared state and coordinating async workflows.

.NETASP.NET CoreC#

Debugging scenarioHard~12 min

Prevent deadlocks with consistent lock ordering

Finds circular lock acquisition and replaces timing-dependent nested locking with a stable order or a simpler ownership boundary.

Debugging scenarioMedium~10 min

Race condition in shared state

Investigate and fix a race condition caused by shared mutable state in a .NET service.

.NETASP.NET CoreC#

Concept questionMedium~7 min

Thread-safe lazy initialization in .NET

Uses runtime-supported initialization rather than timing-dependent manual checks and defines failure, retry, and disposal behavior explicitly.

Architecture scenarioMedium~10 min

Use immutable snapshots instead of shared mutable state

Redesigns read-heavy shared state so readers observe a complete version without coordinating every access through a lock.

Concept questionMedium~7 min

Using SemaphoreSlim for concurrency limits

Use SemaphoreSlim to bound concurrent asynchronous work without blocking threads unnecessarily.

.NETASP.NET CoreC#

Comparison questionHard~9 min

When ReaderWriterLockSlim helps and when it hurts

Evaluates whether read-heavy access justifies a reader/writer lock instead of a simpler lock or immutable snapshot.

Concept questionHard~9 min

Why volatile does not make compound operations thread-safe

Separates memory visibility and ordering from atomic multi-step updates, avoiding volatile as a substitute for real synchronization.