Start Debugging

Tag: performance

82 posts · Page 1 of 9

2026-10-31 comparison csharp dotnet

yield return iterator vs returning a List<T>: what an IEnumerable method actually costs in C#

A yield return method costs one 40-byte state machine object per call no matter how many items it produces; a List<T> costs the whole backing array up front. Measured on .NET 10.0.10: iterator wins on memory and early exit, List<T> wins when the caller enumerates more than once, needs Count, or calls ToList().

2026-10-30 comparison csharp dotnet

ref T loop vs Span<T> indexing in C#: why the span version is as fast or faster in .NET 10

On .NET 10 a plain for loop over span[i] bounded by span.Length compiles to a bounds-check-free, strength-reduced, down-counting loop. A hand-written Unsafe.Add(ref r, i) loop with an int index keeps a sign extension and an up-counting compare, and measured 2-5% slower. Benchmarks and JIT disassembly for arm64 and x64 on .NET 10.0.10.

2026-10-27 csharp dotnet performance

How to iterate over two collections in lockstep without heap allocations in C#

Enumerable.Zip allocates 144-208 bytes per call and runs about 10x slower than a plain loop. For arrays and lists, a for loop over two spans sliced to the same length is allocation-free and the fastest option; for foreach syntax, a small ref struct zip enumerator gets within 25% of it. Measured on .NET 10.0.10 and .NET 11 RC 3.

2026-10-22 comparison csharp dotnet

Lazy<T> vs LazyInitializer.EnsureInitialized vs double-checked locking in C#

Use Lazy<T> by default: it runs the factory once, caches exceptions, and its reads are too cheap to measure after initialization. Use LazyInitializer.EnsureInitialized when you lazily fill many fields or array slots and cannot afford an extra object per value. Hand-written double-checked locking is almost never worth it on .NET 10.

2026-10-21 dotnet dotnet-10 caching

What happens to an expired MemoryCache entry, and when is it actually removed from memory?

An expired MemoryCache entry is not removed on a timer. It stays in the dictionary until a read touches it, a throttled background scan runs, or compaction kicks in. Here is exactly when each happens, and how to get eager eviction.

2026-10-14 comparison csharp dotnet

Thread.Sleep vs Task.Delay vs SpinWait for waiting in C#

Use await Task.Delay for any timed wait in async code, Thread.Sleep only on a dedicated thread you own, and SpinWait only for sub-microsecond waits inside lock-free code. To wait for a condition, use a signal (ManualResetEventSlim, SemaphoreSlim, TaskCompletionSource) instead of any of the three. Measured on .NET 10.0.10.

2026-10-10 ef-core ef-core-11 dotnet-11

What Is a Compiled Model in EF Core 11, and When Is It Worth Enabling?

A compiled model is generated C# that recreates your EF Core model without running OnModelCreating. Measured on EF Core 11 RC1: model load drops from 714 ms to 215 ms at 500 entities, but the MSBuild route (which replaced EFOptimizeContext) is slower, stale models fail silently, and query filters block generation.

2026-10-10 dotnet-11 csharp interop

What Is Transparent Struct Layout, and Why Does a Single-Field Wrapper Struct Change the Calling Convention in .NET?

A transparent struct is one the ABI treats exactly like its only field. .NET 11 has no such guarantee: a struct wrapping a double is passed in RCX on Windows x64 but in XMM0 on Linux and macOS. Here is the disassembly from the .NET 11 JIT on three ABIs, the P/Invoke bugs it causes, and how to write wrapper types that are safe at every boundary.

2026-10-08 comparison ef-core dotnet

AddDbContextPool vs AddDbContextFactory for running EF Core queries in parallel

AddDbContextPool hands out one scoped DbContext per DI scope, so it cannot run two queries at once. AddDbContextFactory and AddPooledDbContextFactory give you a context per call, which is what parallel queries need. Measured on EF Core 11 RC 1: the pooled factory creates a context in 342 ns and 40 B versus 17 us and 44 KB.

2026-10-03 csharp dotnet async

How to wait for a ValueTask synchronously in a non-async method without allocating

Check IsCompleted first and read the result through GetAwaiter().GetResult(), which costs 0 bytes. Only fall back to blocking when the ValueTask is still pending, and do that with a cached event and UnsafeOnCompleted instead of AsTask(), which allocates 72 to 208 bytes per call. Measured on .NET 10 and .NET 11 RC1.