Loading
Pick a focused question that fits your time, stack, and interview goal.
24 results across 1 active filter
Page 1 of 1
Connects EF Core change tracking to object retention, query shape, projections, and read-only API performance.
Shows how publisher-to-subscriber references can retain objects and how to clean up event-based lifetimes.
Focuses on ToList chains, collection capacity, repeated enumeration, and memory-aware data shaping.
Introduces managed heap cleanup, generational collection, object lifetime, and why allocation behavior affects .NET services.
Explains when to capture dumps, what to compare, and how to use roots without turning dumps into guesswork.
Covers allocation rate, collection frequency, latency symptoms, and safe production steps for GC-heavy services.
Uses file upload processing to practice bounded memory, stream ownership, temporary files, and retained buffers.
Covers chunking, bounded concurrency, scoped dependencies, progress, retries, and avoiding full-dataset memory spikes.
Turns LOH theory into an API investigation around large payloads, buffers, serialization, and concurrency.
Gives a practical incident flow for memory growth using metrics, traffic correlation, heap evidence, and safe mitigation.
Frames allocation reduction as measurement-driven API work rather than premature micro-optimization.
Clarifies the difference between objects being retained accidentally and code simply allocating too much temporary memory.
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 why memory diagnostics need access control, retention limits, and careful handling of secrets and user data.
Practices incident response after an OOM: restore service, collect evidence, identify trigger, and prevent recurrence.
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.
Covers large exports, uploads, and API responses where bounded memory matters more than convenience.
Introduces lower-level allocation tools while emphasizing measurement, ownership, and safe usage.
Identifies useful memory and GC signals for alerting without overwhelming the team with noisy telemetry.
Covers the Large Object Heap, big buffers, fragmentation pressure, and practical ways to avoid loading too much at once.
Explains cache memory growth, eviction, size limits, stale data, and why cache design needs explicit bounds.
Reviews a captive scoped dependency as both a lifetime and concurrency bug, then replaces it with explicit per-operation scopes and minimal immutable work data.