{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the main advantage of BenchmarkDotNet over a simple Stopwatch for measuring performance?","acceptedAnswer":{"@type":"Answer","text":"BenchmarkDotNet performs warm-ups, measures multiple iterations with statistical stabilization, avoids JIT and GC biases. A simple Stopwatch can give unrepresentative results as it doesn't control these factors. BenchmarkDotNet also provides detailed metrics like memory allocations per operation."}},{"@type":"Question","name":"Which Microsoft tool is recommended for analyzing memory allocations and identifying memory leaks in production?","acceptedAnswer":{"@type":"Answer","text":"dotMemory from JetBrains and PerfView from Microsoft are recommended tools for profiling memory in .NET. PerfView is free, open-source and can analyze heap allocations, stack traces and GC events. It is particularly suitable for diagnosing memory leaks in production without significant overhead."}},{"@type":"Question","name":"How to identify hidden memory allocations in a LINQ method like FirstOrDefault()?","acceptedAnswer":{"@type":"Answer","text":"Using BenchmarkDotNet with MemoryDiagnoser attribute shows allocations per operation. LINQ lambdas create hidden allocations via delegates. Replacing with a simple foreach loop eliminates these allocations. PerfView can also capture allocation stack traces to identify sources."}},{"@type":"Question","name":"In BenchmarkDotNet, which attribute to use for measuring CPU performance and identifying code hotspots?","acceptedAnswer":{"@type":"Answer","text":"DisassemblyDiagnoser attribute shows generated assembly code and identifies JIT optimizations. For CPU profiling, use an external profiler like dotTrace or PerfView alongside BenchmarkDotNet. HardwareCounters can also measure CPU instructions, cache misses and branch mispredictions to identify hotspots."}},{"@type":"Question","name":"How to interpret a BenchmarkDotNet result showing Mean: 125.3 ns, StdDev: 45.2 ns?","acceptedAnswer":{"@type":"Answer","text":"A high standard deviation (StdDev) of 45.2 ns on a mean of 125.3 ns indicates significant variance (36%). This can signal JIT bias, unstabilized GC or system variations. Need to increase iterations, verify warm-ups and potentially isolate the process to get more stable results."}},{"@type":"Question","name":"How to detect performance regression in a CI/CD pipeline with BenchmarkDotNet?","acceptedAnswer":{"@type":"Answer","text":"Export BenchmarkDotNet results as JSON, compare with stored baseline results and define acceptable regression thresholds (e.g. +10%). Tools like BenchmarkDotNet.ResultsComparer or custom scripts can automate this comparison. Important to run on dedicated hardware to avoid variations."}},{"@type":"Question","name":"What is the performance impact of boxing an int to object in a loop of 1 million iterations?","acceptedAnswer":{"@type":"Answer","text":"Each boxing creates a heap allocation (24 bytes on x64). For 1 million iterations, this represents 24 MB of allocations generating significant GC pressure. Boxing also costs CPU cycles for allocation and copy. Using generic types completely avoids this overhead by preserving value types."}},{"@type":"Question","name":"What is the main advantage of Span over T[] for temporary operations on data?","acceptedAnswer":{"@type":"Answer","text":"Span is a stack-allocated ref struct requiring no heap allocation. It allows creating views on existing memory segments without copying. For temporary operations, this completely avoids allocations and GC pressure. Additionally, Span can point to stack memory (via stackalloc), unmanaged memory or existing arrays."}},{"@type":"Question","name":"In which scenario to use stackalloc instead of a regular array?","acceptedAnswer":{"@type":"Answer","text":"stackalloc allocates on stack, avoiding heap allocations and GC. Ideal for small temporary buffers (< 1 KB recommended) used within a single method. Beyond a few KB, risk of stack overflow. Perfect for temporary cryptographic calculations, string parsing or ephemeral network buffers with Span."}},{"@type":"Question","name":"How to use ArrayPool to optimize allocations in a high-performance web server?","acceptedAnswer":{"@type":"Answer","text":"ArrayPool.Shared provides a pool of reusable arrays. Call Rent() to get an array, use it, then Return() to return it to the pool. This avoids millions of allocations in a server handling 10000+ requests/sec. Critical: always Return() (use using or try/finally), clear sensitive data before Return(), accept that returned array may be larger than requested."}},{"@type":"Question","name":"What is the performance difference between ValueTask and Task for a method that is often synchronous?","acceptedAnswer":{"@type":"Answer","text":"ValueTask is a struct that can return a synchronous result without heap allocation. When result is immediately available (e.g. cache hit 95% of time), ValueTask avoids allocating a Task. For always-async or rarely-called methods, Task remains preferable as ValueTask has restrictions (no multiple await, no storage in fields)."}},{"@type":"Question","name":"How to optimize StringBuilder performance when final size is approximately known?","acceptedAnswer":{"@type":"Answer","text":"Specifying initial capacity via StringBuilder(capacity) constructor avoids multiple reallocations and copies of internal buffer. Without capacity, StringBuilder doubles its size on each overflow (16 → 32 → 64...), causing costly allocations and copies. If building a ~2KB JSON, initializing with new StringBuilder(2048) improves performance by 30-50%."}},{"@type":"Question","name":"What is the advantage of string interning for repetitive strings like configuration constants?","acceptedAnswer":{"@type":"Answer","text":"String.Intern() stores a single instance of the string in CLR's internal pool. For strings repeated thousands of times (e.g. \"ConnectionString\" in a cache), this drastically reduces memory usage. Comparisons also become reference comparisons (very fast). Warning: interned strings are never garbage collected, so use only for long-lived strings."}},{"@type":"Question","name":"How does Lazy improve performance when initializing costly objects that are rarely used?","acceptedAnswer":{"@type":"Answer","text":"Lazy defers initialization until first access to Value property. If object is never used (e.g. fallback service 1% of time), costly initialization never occurs. For a service requiring 200ms initialization but used only 5% of time, this avoids 95% of startup time. Lazy is also thread-safe by default."}},{"@type":"Question","name":"What is the impact of GC generations (Gen0, Gen1, Gen2) on web application performance?","acceptedAnswer":{"@type":"Answer","text":"Gen0 contains short-lived objects and is collected frequently (< 1ms). Gen1 is an intermediate buffer. Gen2 contains long-lived objects and its collection is expensive (10-100ms), blocking all threads. In a web app, too many objects promoted to Gen2 cause noticeable pauses. Goal: most objects die in Gen0. Minimizing allocations and using object pooling reduces GC pressure."}},{"@type":"Question","name":"How to optimize allocations to avoid Large Object Heap (LOH) and its fragmentation issues?","acceptedAnswer":{"@type":"Answer","text":"LOH stores objects ≥ 85KB and is never compacted by default, causing fragmentation. Strategies: use ArrayPool to reuse large buffers, segment data into chunks < 85KB, enable LOH compaction explicitly with GCSettings.LargeObjectHeapCompactionMode (but expensive). For a frequent 1MB buffer, ArrayPool completely avoids LOH."}},{"@type":"Question","name":"What is the performance impact of a finalizer (destructor ~ClassName) on a frequently allocated object?","acceptedAnswer":{"@type":"Answer","text":"Finalizers force object to survive an additional GC collection (promotion to higher generation). Object is only freed after passing through finalization queue. For frequent objects (10000/sec), this drastically increases GC pressure and promotions to Gen2. Prefer IDisposable with Dispose pattern and avoid finalizers unless absolutely necessary (unmanaged resources)."}},{"@type":"Question","name":"How to correctly implement IDisposable to ensure fast resource release while avoiding leaks?","acceptedAnswer":{"@type":"Answer","text":"Implement standard Dispose pattern: public Dispose() method calling Dispose(bool disposing), suppress finalizer with GC.SuppressFinalize(this), and release managed resources if disposing=true and unmanaged always. Use using or using declaration to guarantee call. Never throw exceptions in Dispose(). Make method idempotent (can be called multiple times)."}},{"@type":"Question","name":"What is the main performance issue with LINQ FirstOrDefault() using a lambda on a list of 100000 elements?","acceptedAnswer":{"@type":"Answer","text":"FirstOrDefault with lambda creates a heap allocation for the delegate (closure) on each call. On 100000 elements traversed frequently, this generates millions of allocations. Replacing with simple foreach loop eliminates these allocations. Delegate allocation is often invisible but measurable with BenchmarkDotNet MemoryDiagnoser. Typical gain: 40-60% reduction in allocations."}},{"@type":"Question","name":"What is the async/await best practice to avoid deadlocks in a reusable library?","acceptedAnswer":{"@type":"Answer","text":"Always use ConfigureAwait(false) in libraries to avoid capturing SynchronizationContext. Without it, code can deadlock in UI apps (WPF, WinForms) or ASP.NET Framework. ConfigureAwait(false) allows continuation to run on any ThreadPool thread. In ASP.NET Core, less critical but still good practice for performance (avoids context switch)."}},{"@type":"Question","name":"What is the performance order (fastest to slowest) for iterating 1 million elements: Span, Array T[], List?","acceptedAnswer":{"@type":"Answer","text":"Span is fastest as it enables aggressive JIT optimizations (bounds check elimination, SIMD vectorization). Array T[] is very close but with light bounds checking. List is slowest as it adds indirection (access via internal _items field) and version checks. Typical difference: Span 100%, Array 102%, List 115% of time. For hot paths, prefer Span or Array."}},{"@type":"Question","name":"In which scenario to prefer a struct instead of a class to optimize memory performance?","acceptedAnswer":{"@type":"Answer","text":"Prefer struct for small types (< 16 bytes recommended), immutable and frequently copied (e.g. Point, Vector2, DateTime). Structs avoid heap allocations and GC but are copied by value. For collections of 1 million Point structs vs classes, saves ~32 MB of heap and eliminates GC pressure. Avoid structs for types > 16 bytes (copy cost) or mutable (semantic confusion)."}}]}