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 3 of 4
Uses nullable annotations as a compile-time contract while still validating untrusted and legacy runtime inputs.
Separates compile-time overload selection from runtime virtual dispatch and diagnoses method hiding through a base reference.
Parses a simple filter expression into a validated dictionary without accepting arbitrary keys.
Uses type, property, relational, and list patterns to express decisions while keeping null and unhandled cases explicit.
Separates restricted mutation access from a stable immutable value and chooses snapshots or structural sharing deliberately.
Implements safe redaction of known sensitive keys in a dictionary before logging.
Uses metadata-driven behavior deliberately and protects reflection-dependent code when publishing with trimming or ahead-of-time compilation.
Implements a bounded async retry helper that respects cancellation and does not retry every exception blindly.
Implements top-K frequency selection with deterministic tie-breaking.
Explains how callers use one contract while runtime dispatch selects implementation, then connects that mechanism to extensible behavior.
Explains the output shape of core LINQ transformations and uses them without hiding empty groups, duplicate keys, or excessive buffering.
Uses static members for type-wide stateless behavior and constants while avoiding hidden global mutable state and lifetime problems.
Distinguishes operators that can yield incrementally from operators that must consume substantial input before producing results.
Uses async streams for incremental asynchronous production while preserving cancellation, disposal, backpressure expectations, and API boundaries.
Compare Task and Thread in .NET, including abstraction level, scheduling, and when direct thread management is rarely appropriate.
Moves invariant-sensitive decisions toward the owning object while keeping orchestration, queries, and cross-boundary work appropriately explicit.
Implements a small validation helper for date ranges with clear error messages.
Explains what is copied when values and object references are assigned or passed, including the explicit effect of ref, out, and in.
Explain the async state machine, continuation scheduling, and exception flow when a C# method awaits a Task.
Explains how GC roots retain reachable object graphs and turns heap evidence into a concrete ownership fix for static state, events, closures, queues, and caches.
Explains string immutability, concatenation behavior, and pragmatic use of StringBuilder in .NET.
Distinguishes deterministic cleanup from finalization and explains resource ownership in normal application code.
Explains asynchronous cleanup for resources whose shutdown path needs async work, such as flushing or closing remote connections.
Introduces lower-level allocation tools while emphasizing measurement, ownership, and safe usage.