Loading
Pick a focused question that fits your time, stack, and interview goal.
74 results across 1 active filter
Page 1 of 4
Separates hiding implementation complexity from controlling access to state, with practical examples where both ideas work together.
Uses public, internal, protected, private, and protected internal deliberately to control API surface and inheritance exposure.
Aggregates log entries into per-minute error counts with deterministic output.
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.
Explains when a value is wrapped as an object, why unboxing is exact, and how generic APIs can avoid hidden allocations.
Implements a safe in-memory paging helper with metadata and boundary handling.
Implements invoice total calculation with quantity, unit price, percentage discount, and rounding.
Chooses contracts and shared implementation based on substitutability, state ownership, evolution, and inheritance constraints.
Chooses a sequential collection from size, mutation, access pattern, memory locality, and the behavior callers actually need.
Avoids hidden quadratic work by indexing repeated matches while preserving duplicate, missing, ordering, and memory semantics.
Chooses a type shape from identity, value semantics, mutation, copy cost, default values, and serialization boundaries.
Creates valid objects with clear intent while choosing construction patterns proportionally to optional data, validation, and lifecycle complexity.
Separates ordinal identity comparison from culture-aware display ordering and keeps hash-based collection semantics consistent.
Chooses between sequence, counted, indexed, set, and dictionary contracts based on required operations and complexity.
Implements chunking for batch processing without dropping final partial batches.
Explains what a lambda captures, how captured state is shared, and why a long-lived callback can retain more memory than expected.
Uses complexity as a first filter while accounting for constants, locality, allocations, data size, and the complete operation sequence.
Implements comparison for simple semantic version strings with missing patch parts treated as zero.
Combines focused collaborators for independent behavior while recognizing cases where a genuine stable hierarchy remains simpler.
Explain what ConfigureAwait(false) does, why it mattered historically, and how to reason about it in ASP.NET Core and library code.
Implements a word-frequency counter with normalization, punctuation handling, and stable ordering.
Distinguishes instants, local calendar values, offsets, and named time zones so APIs and persistence survive daylight-saving and locale boundaries.
Implements duplicate suppression while preserving the first event for each idempotency key.