The performance and Native AOT cheat sheet

Enumerable.DistinctBy keeps the first element per key. To keep the last one and still return results in the order they appear in the source, buffer the input, scan it backwards with a HashSet, and yield the survivors forwards. Eight implementations checked for order, null keys, double enumeration and argument validation on .NET 10.0.10 and .NET 11 RC3, and benchmarked on .NET 10.

OrderBy(...).ThenBy(...) runs every key selector for every element before it compares anything, even when the OrderBy keys are already unique. Measured on .NET 10 and .NET 11 RC3: what the runtime does, why the popular lazy-key workaround still computes keys it never needs, and three patterns that call an expensive secondary key only for tied elements.

foreach over (ReadOnlySpan<T>)[a, b] allocates nothing on .NET 8 and later and works for reference types, which stackalloc cannot do. On .NET 10 the compiler backs it with the BCL's InlineArray2<T>, and the JIT can even stack-allocate a plain new[] { a, b } once the method reaches Tier 1. Measured on .NET 10.0.10 and .NET 11 RC 3.

List<T>.Sort, Array.Sort, Span<T>.Sort and ImmutableArray.Sort are unstable introsorts, so items with equal keys can swap places. Enumerable.OrderBy is stable. Measured on .NET 10: why lists of 16 or fewer items look stable, why three items are not, how to get a stable in-place sort, and what it costs.

On .NET Core and .NET 5+ Stopwatch.IsHighResolution is a hard-coded true and never false. Frequency is whatever QueryPerformanceFrequency says on Windows (usually 10 MHz) and a fixed 1,000,000,000 on Linux, macOS, iOS, Android and WASM, which is a unit, not a resolution. Only .NET Framework can fall back to DateTime. Source walkthrough plus a measured run on .NET 10 / Apple M4 showing 1 ns nominal ticks but 41.67 ns real steps.

[ModuleInitializer] makes the C# compiler emit a <Module> static constructor that calls your method once per assembly. When it runs is looser than most people think: on the JIT it can fire before a branch that never executes, under Native AOT it runs eagerly at startup or not at all. Why CA2255 warns libraries off it, the few cases where a library should still use it, and measured behaviour on .NET 10.

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().

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.

Return bool from a TryX method when failure is an ordinary outcome the caller will branch on, and throw when it is a bug or a broken precondition. Measured on .NET 10.0.10: a failed int.TryParse costs 4.9 ns, a caught FormatException costs 2,487 ns.

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.

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.

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.

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.

FluentValidation 12.2.0, released October 10, 2026, swaps Enum.GetValues for Enum.GetValuesAsUnderlyingType inside EnumValidator, so IsInEnum() on a [Flags] enum no longer throws NotSupportedException in a native AOT binary.

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.

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.

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.

C# Dev Kit 11.0 pre-release replaces six managed processes with a single Native AOT CSDevKit process and a persistent project cache. A 407-project Aspire solution is ready in 3.0s instead of 84.1s, using 316 MB instead of 2,072 MB.

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.

EF.Constant inlines a captured value as a SQL literal, EF.Parameter turns a literal into a SQL parameter. Keep EF Core's defaults, use EF.Parameter to stop dynamically built expression trees from recompiling on every call, and use EF.Constant only for a value with a handful of distinct values whose data is skewed enough to need its own plan.

Volatile.Read is an acquire load of one location. Volatile.ReadBarrier, new in .NET 10, is a fence that gives every earlier read acquire semantics. Use Volatile.Read for flags and published references, and ReadBarrier when you need a batch of plain or non-atomic reads to complete before the next memory access, as in a seqlock.

A monorepo with dozens of pubspec.yaml files makes the Dart analysis server build one analysis context per package, which is where the memory and the minute-long startup go. Convert to a pub workspace, exclude generated code in analysis_options.yaml, drop legacy analyzer plugins, and use the Insights page to prove it. Measured on Dart 3.12.2: 2.3x less peak memory and half the cold analysis time.

Ship skwasm with flutter build web --wasm when your dependencies compile to Wasm: it downloads less and rendered 36% more frames than CanvasKit on a heavy scene. On Flutter 3.47.x, keep it single-threaded until the multi-threaded text crash fix leaves beta.

Stephen Toub's Performance Improvements in .NET 11 post shows generic virtual method calls dropping from 6.7 ns and 24 bytes to 1.8 ns and zero allocation. Three RyuJIT pull requests unlocked inlining on the dispatch that used to be the most opaque one in .NET.

Use ToLookup when you group once and only read: it is immutable, returns an empty sequence for missing keys, accepts null keys and keeps first-seen order. Use Dictionary<TKey, List<TValue>> when the groups change after construction or cross a JSON boundary.

EF Core's build-time model generation re-entered MSBuild until RAM ran out. Upgrade Tasks and Design to 10.0.10+, and on EF Core 11 delete EFOptimizeContext.

Play Console tells you your ANR rate is over 0.47% and hands you a native stack full of libcoreclr.so frames. Here is how to get from that useless trace to the exact async void event handler that blocked the main thread, using a Looper printer, a SynchronizationContext wrapper that names the state machine, and dotnet-trace over dsrouter.

MSTest 4.4 moves MSTest.SourceGeneration out of experimental and aligns it with the MSTest version. Native AOT test projects pick it up with no opt-in, ReflectionFree mode can now skip runtime discovery for plain [TestMethod] and [DataRow], and five AOTSG diagnostics tell you which test shapes will not survive.

W^X (write xor execute) is the rule that no memory page is writable and executable at the same time. In .NET it is the DOTNET_EnableWriteXorExecute knob, on by default since .NET 7, and it exists entirely for the JIT. Native AOT never reads it. Here is how the runtime implements it, what it costs, and when turning it off is a legitimate fix.

Framework-dependent on a chiseled aspnet image is the right default for an ASP.NET Core service on .NET 11, because the runtime layer is shared across services and a runtime CVE is fixed by a base image bump. Self-contained trimmed and Native AOT buy a 2x to 5x smaller image and a much faster cold start, and cost you that. Real published sizes, the layer-sharing math, and the .NET 11 base image inference bug that breaks the AOT path.

Eliding async/await in a repository passthrough saves about 6 ns and 72 bytes, and costs you a stack frame, try/catch semantics, and safe disposal. Keep return await unless the method is a pure passthrough on a measured hot path.

Mapperly is the default for new .NET code: it matches hand-written speed, survives Native AOT, and catches unmapped members at build time. AutoMapper still wins on ProjectTo. Benchmarks and license thresholds included.

iOS builds set DynamicCodeSupport=false, so EF Core refuses to build the model even though you never enabled NativeAOT. Ship a compiled model plus precompiled queries, or turn the interpreter back on.

There is no HasBeenEnumerated flag on IEnumerable<T>. Here is what TryGetNonEnumeratedCount actually checks, why Enumerable.Range passes an ICollection<T> test, and the guard that avoids a wasted ToList().

CA1873 fires on the implicit params object[] allocation, so almost every LogDebug call trips it. Fix it with [LoggerMessage] or an IsEnabled guard.

Zstandard is the right default for dynamic API responses in .NET 11, but not at the quality the ASP.NET Core provider ships with. Benchmarks on real JSON payloads showing why quality 1 beats the default quality 3 on both size and CPU, when Brotli still wins, and why Gzip survives only as a fallback.

A complete guide to enabling HTTP/3 on Kestrel in ASP.NET Core 11: the HttpProtocols.Http1AndHttp2AndHttp3 endpoint config, MsQuic platform requirements on Windows, Linux, and macOS, why the first request is never HTTP/3, how to verify with HttpClient and middleware, QuicTransportOptions tuning, and the firewall and proxy gotchas that make it silently fall back.

A complete guide to converting new Regex(pattern, RegexOptions.Compiled) into [GeneratedRegex] in .NET 11: the mechanical rewrite, partial methods vs partial properties, measured startup and throughput numbers, the SYSLIB1040-1045 diagnostics, and the two patterns where the generator silently falls back to a cached Regex.

A complete guide to offloading CPU-bound work off the Blazor WebAssembly UI thread in .NET 11: why Task.Run does not help, the new blazorwebworker template, the WebWorkerClient API with cancellation and timeouts, the JSExport marshalling limits, and the second-runtime cost you pay per worker.

This InvalidOperationException means PublishTrimmed or PublishAot flipped JsonSerializerIsReflectionEnabledByDefault to false. Fix it with a source-generated JsonSerializerContext.

A complete guide to shipping a Flutter web app compiled to WebAssembly on Flutter 3.44: what the two emitted builds look like, why Firefox and Safari still get JavaScript because of the loader's wasmAllowList, migrating off dart:html for dart2wasm, the COOP/COEP headers that decide whether skwasm runs multi-threaded, and how to prove at runtime which build the browser actually loaded.

A complete workflow for finding a managed memory leak in .NET 11: confirm growth with dotnet-counters, take two gcdumps and diff them, then collect a dump and use dumpheap, gcroot, and objsize in dotnet-dump analyze to find what is still holding the reference.

Use CreateBuilder for a normal app, CreateSlimBuilder when you publish trimmed or Native AOT behind a TLS proxy, and CreateEmptyBuilder only when you want to register every service yourself. Here is the feature matrix and the gotchas that force the call.

Output caching is the right default for almost every server-side app in ASP.NET Core 11. Response caching only wins when your goal is to steer browser and proxy caches through HTTP headers. Here is the decision, with a feature matrix and the gotchas that force the call.

A complete guide to response compression in ASP.NET Core 11: AddResponseCompression and UseResponseCompression, the new built-in Zstandard provider alongside Brotli and Gzip, compression levels, EnableForHttps and the CRIME/BREACH risk, custom MIME types, middleware ordering, and when to let the reverse proxy do it instead.

A complete, working guide to output caching in an ASP.NET Core 11 minimal API: AddOutputCache and UseOutputCache, CacheOutput on endpoints and MapGroup, named and base policies, Expire, VaryByQuery and VaryByHeader, tag-based eviction with EvictByTagAsync, cache stampede protection, ETag revalidation, and a Redis backing store.

As the .NET 11 previews progress toward the November release, Runtime Async has graduated: net11.0 projects opt in with a single MSBuild property, and the runtime libraries themselves now ship compiled on it.

PGO (profile-guided optimization) lets the .NET JIT specialize hot code for the types and branches your workload actually hits. Dynamic PGO has been on by default since .NET 8, so on .NET 8 and later you do not need to opt in. Here is what it does, how to see its effect, and the rare cases where you touch the knob.

Tiered compilation lets the .NET JIT compile every method twice: once fast and unoptimized to get your app running, then again with full optimizations once the runtime knows a method is hot. Here is how tier 0, tier 1, on-stack replacement, and Dynamic PGO fit together, and how to observe and tune them.

Trim-safe code is code the .NET trimmer can statically prove is reachable, so it survives when unused code is removed from a self-contained app. This is the practical guide: turn on the analyzer, drive every IL2xxx warning to zero, annotate reflection with DynamicallyAccessedMembers, propagate RequiresUnreferencedCode to public APIs, and replace unanalyzable patterns with source generators.

SkiaSharp 4.148.0 is the first stable v4 release. GPU-heavy UIs render up to 24% faster, CPU shaders run ~6x faster, and the legacy API surface is finally retired. Here is what upgrading actually costs you.

Replace Skip/Take with a WHERE clause that seeks past the last row you saw. Order by a fully unique key, carry the last row's values as a cursor, and EF Core 11 turns the next page into an index seek instead of an OFFSET scan.

Span<T> can avoid temporary copies and allocations when parsing or formatting contiguous memory. Learn what it owns, lifetime limits and what to measure.

DynamicallyAccessedMembers tells the .NET trimmer and AOT compiler which members of a Type you reach by reflection, so they are kept instead of trimmed away. It turns a silent runtime MissingMethodException into a build-time IL2070 warning. Here is what the attribute does, how the data-flow analysis behind it works, and how to annotate parameters, fields, and generic type parameters correctly.

ValueTask and ValueTask<T> are structs that let an async method return a result without heap-allocating a Task when it completes synchronously. The win is one fewer allocation on hot paths that usually finish without awaiting. The cost is a strict await-once contract. Here is what the type actually is, how it works, and the narrow set of cases where it earns its keep.

Native AOT compiles your .NET app to a single self-contained native binary with no JIT, buying fast startup and a small memory footprint. The price is a C toolchain at build time, slower publishes, per-RID builds, no reflection or Reflection.Emit, mandatory trimming, and no Dynamic PGO. Here is the full ledger.

Use AsNoTracking for read-only queries by default. Reach for AsNoTrackingWithIdentityResolution only when the result graph contains the same entity more than once and your code depends on getting a single shared instance back.

Default to HybridCache for new caching code in .NET 11. Reach for IMemoryCache only when you need raw single-server speed with no serialization, and IDistributedCache only as a backing store. Here is the decision matrix.

.NET 11 Preview 5 adds a brand-new FullJoin operator to LINQ plus tuple-returning overloads for Join, LeftJoin, RightJoin, and GroupJoin that drop the result selector entirely.

Wire HybridCache to a Redis L2 in ASP.NET Core 11: register the service, add the StackExchange Redis distributed cache, and let GetOrCreateAsync give you a two-tier cache with built-in stampede protection and tag invalidation.

A practical checklist for reverting ValueTask and ValueTask<T> return types to Task and Task<T>, what breaks at the call sites, how to verify each change, and how to know whether the swap was ever worth it.

A decision guide and real benchmark for EF Core 11: use ExecuteUpdate for set-based writes by a predicate, and the load-then-SaveChanges path only when you need the change tracker, interceptors, or a complex object graph.

.NET 11 Preview 4 drops support for pre-2013 x86/x64 chips and bumps the JIT baseline to x86-64-v2. Here is what breaks, why, and how to check your hardware before you upgrade.

.NET 11 Preview 4 teaches double, float, and Half to format with the X specifier and parse with NumberStyles.HexFloat, producing the same IEEE-754 hex text as C printf("%a").

When you Include two sibling collections, EF Core 11 returns the cross product and your row count explodes. Here is how AsSplitQuery fixes it, how to turn it on globally, and the consistency and ordering gotchas to watch for.

A complete guide to ExecuteUpdate and ExecuteDelete in EF Core 11: the SQL they emit, the change-tracker gotcha that silently overwrites your bulk write, transactions, concurrency control with the affected-row count, and the EF Core 10 delegate setters that let you build conditional updates with plain if statements.

Choose List<T> for a growable collection, Span<T> for a mutable view, and ReadOnlySpan<T> for reading contiguous memory. Understand lifetime and async limits.

Use Parallel.ForEach for CPU-bound work over in-memory data, Parallel.ForEachAsync for async I/O over many items with a concurrency cap, and Task.WhenAll for a small fixed fan-out where you want every operation in flight and need the results back.

Use string interpolation for one-shot composition of a fixed set of values; use StringBuilder when you append in a loop or across an unknown number of pieces. The dividing line is the loop, not the number of values.

.NET 11 Preview 4 ships DeflateEncoder, GZipEncoder, and ZLibEncoder plus matching decoders so you can compress straight into a Span<byte> with OperationStatus, no Stream required.

For read-heavy paths in .NET 11, plain EF Core with AsNoTracking is within ~5% of Dapper. Reach for compiled queries on a profiled single-row hot path, and Dapper only for the lowest latency or SQL LINQ can't express.

Plain JIT with Dynamic PGO wins steady-state throughput, ReadyToRun cuts startup with zero code changes, and Native AOT gives the smallest, fastest-starting binary at the cost of reflection and dynamic code. Pick by deployment shape, not raw benchmarks.

Native AOT strips the JIT and the interpreter, so reflection emit, expression-tree compilation, and unseen MakeGenericType throw at runtime. Find the call via IL3050 and replace it with a source generator or a pre-baked path.

Microsoft moved Copilot Studio's WASM engine from .NET 8 to .NET 10. The dual JIT/AOT package, fingerprinting, and WasmStripILAfterAOT explain the numbers.

Step-by-step guide to finding and fixing jank in Flutter 3.27 with DevTools: profile mode, the Performance overlay, the Frame Analysis tab, the CPU Profiler, raster vs UI thread, shader warm-up, and Impeller-specific gotchas. Tested on Flutter 3.27.1, Dart 3.11, DevTools 2.40.

When async/await is not enough: spawn a Dart isolate to run CPU-bound work off the UI thread. Isolate.run, Flutter's compute, long-lived workers with SendPort/ReceivePort, what can cross the boundary, and the JS/web caveat. Tested on Dart 3.11 and Flutter 3.27.1.

Three ways to wrap a T[] in a ReadOnlyMemory<T> in .NET 11: the implicit conversion, the explicit constructor, and AsMemory(). When each is the right call.

A practical guide to spotting N+1 queries in EF Core 11: what the pattern looks like in real code, how to surface it via logging, diagnostic interceptors, OpenTelemetry, and a test that fails the build when a hot path regresses.

A practical guide to EF Core 11 compiled queries: when EF.CompileAsyncQuery actually wins, the static-field pattern, the Include and tracking gotchas, and how to benchmark before and after so you can prove it was worth the extra ceremony.

SearchValues<T> beats IndexOfAny by 5x to 250x but only when you use it the way the runtime expects. The cache-as-static rule, the StringComparison gotcha, when not to bother, and the IndexOfAnyExcept inversion trick that nobody documents.

A practical, version-specific playbook for cutting .NET 11 Lambda cold starts. Covers Native AOT on provided.al2023, ReadyToRun, SnapStart on the managed dotnet10 runtime, memory tuning, static reuse, trim safety, and how to actually read INIT_DURATION.

Configure a Minimal API for Native AOT with generated JSON metadata. Understand builder choices, deployment toolchains, warnings and feature limitations.

EF Core builds its conceptual model lazily on the first DbContext access, which is why the first query in a fresh process is several hundred milliseconds slower than every query after it. This guide covers the three real fixes in EF Core 11: a startup IHostedService that touches Model and opens a connection, dotnet ef dbcontext optimize to ship a precompiled model, and the cache-key footguns that silently rebuild the model anyway.

A complete guide to profiling .NET 11 apps with dotnet-trace: install, pick the right profile, capture from startup, and read the .nettrace output in PerfView, Visual Studio, Speedscope, or Perfetto.

Ubuntu 26.04 Resolute Raccoon ships with .NET 10 in the archive, introduces -resolute container tags to replace -noble, and packages Native AOT tooling via dotnet-sdk-aot-10.0.

Stream a multi-gigabyte CSV in .NET 11 without OutOfMemoryException. File.ReadLines, CsvHelper, Sylvan, and Pipelines compared with code and measurements.

Serve large files from ASP.NET Core 11 without loading them into memory. Three tiers: PhysicalFileResult for on-disk files, Results.Stream for arbitrary streams, and Response.BodyWriter for generated payloads -- with code for each.

The C# Dev Kit team swapped its C++ Node.js addon for a .NET 10 Native AOT library, using N-API, UnmanagedCallersOnly, and LibraryImport to produce a single .node file without Python or node-gyp.

.NET 11 Preview 3 lets Kestrel serve HTTP/3 requests before the peer's control stream and SETTINGS frame arrive, shaving handshake latency off the first request on every new QUIC connection.

.NET 11 Preview 3 teaches RyuJIT to eliminate redundant bounds checks on consecutive index-from-end access and on i + constant < length patterns, cutting branch pressure in tight loops.

EF Core 11 Preview 3 removes redundant to-one joins from split queries and drops unneeded ORDER BY keys. One reported scenario got 29% faster, another 22%. Here is what the SQL now looks like.

EF Core 11 Preview 3 introduces ChangeTracker.GetEntriesForState, a state-filtered enumerator that avoids an extra DetectChanges pass in hot paths like SaveChanges interceptors and audit hooks.

Loic Baumann's Typhon project targets 1-2 microsecond ACID commits using ref structs, hardware intrinsics, and pinned memory, proving C# can compete at the systems programming level.

C# 14 lets you overload +=, -=, *=, and friends as void instance methods that mutate the receiver in place, cutting allocations for large value holders like BigInteger-style buffers and tensors.

C# strings sent through Dapper default to nvarchar(4000), forcing SQL Server into implicit conversions and full index scans. Here's how to fix it with DbType.AnsiString.

.NET 11 Preview 1 ships ZstandardStream, ZstandardEncoder, and ZstandardDecoder in System.IO.Compression, giving you fast, inbox zstd support with no third-party packages.

Rider 2026.1 adds a .NET Disassembler plugin that lets you inspect machine code generated by the JIT, ReadyToRun, and NativeAOT compilers without leaving the IDE.

Kestrel's HTTP/1.1 request parser in .NET 11 replaces BadHttpRequestException with a result struct, cutting malformed-request overhead by up to 40%.

Runtime Async in .NET 11 moves async/await handling from compiler-generated state machines into the runtime itself, producing readable stack traces, correct breakpoints, and fewer heap allocations.

A new Polars.NET project is trending after a Feb 6, 2026 community post. The headline is simple: a .NET-friendly DataFrame API backed by Rust Polars, with a stable C ABI and LibraryImport-based interop to keep overhead low.

A practical profiling loop for .NET 9 and .NET 10: capture traces with dotnet-trace, visualize them in Perfetto, and iterate on CPU, GC, and thread pool issues.

In .NET 10, the JIT compiler reduces the overhead of iterating arrays through interfaces. See benchmarks comparing .NET 9 vs .NET 10 with foreach, IEnumerable, and conditional escape analysis.

.NET 9 significantly improves ToArray performance using InlineArray, making it faster and more memory-efficient than ToList. See benchmarks comparing .NET 8 vs .NET 9.