Under Windows, one is able to read .NET performance counters using the following: Performance Monitor C# using PerformanceCounter WMI and querying the .NET related classes Considering the recent re... More on stackoverflow.com

"how fast is asp.net core really?" More on reddit.com

It's not documented all in one place neatly like the fasthttp repository. The short answer is that the team is absolutely obsessed with performance. While that's not a specific change, it's that performance culture that has resulted in dramatic performance increases and breakthroughs every single release. We measure everything and track benchmarks closely https://aka.ms/aspnet/benchmarks . The repository is here https://github.com/aspnet/Benchmarks/ . We built tools to measure every single change and report the status so we can measure the impact (e.g. https://github.com/dotnet/aspnetcore/issues/52378 ). We made it trivial for anyone to run end-to-end benchmarks with their changes so developers could experiment with performance changes and get immediate feedback ( https://github.com/dotnet/crank ). Our performance planning is across the entire stack! We look at the JIT, GC and core libraries and think about the investments we can make that will have a huge impact on various benchmarks and app patterns in ASP.NET Core, Maui, etc. Quite frankly, we have amazing developers and contributors that are incentivized by this culture to just make changes to improve things: https://github.com/dotnet/aspnetcore/pull/51803 https://github.com/dotnet/aspnetcore/pull/52106 https://github.com/dotnet/aspnetcore/pull/51815 That's just a sample. Over the last couple of releases, we've started labeling performance work with a label to make it easier to see the work we've done (and blog about it later 😁). https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+label%3APerf+is%3Aclosed https://github.com/dotnet/aspnetcore/issues?q=label%3APerf+is%3Aclosed+-author%3Aapp%2Fpr-benchmarks+ As for a very concrete set of categories things we did to improve the performance: We pool buffers using the pinned object heap to reduce GC heap fragmentation. We pool object where possible (there are no allocations for the requests and responses), they are stored and reused on the connection (in h1) and pooled in (h2 and h3). The HTTP parser is vectorized and doesn't allocate anything (we still need to materialize strings because we expose them in the object model). We rewrote our socket and thread pool implementation in .NET to be more optimized, not allocate and to avoid extra thread hopping where possible. We use ValueTask pooling to avoid allocations for repeating read/write operations. We use 0 byte reads to avoid allocations on the underlying socket until there's data available. You can read about some of these in the following blog posts: https://devblogs.microsoft.com/dotnet/performance-improvements-in-aspnet-core-6/ https://devblogs.microsoft.com/dotnet/performance-improvements-in-aspnet-core-7/ https://devblogs.microsoft.com/dotnet/performance-improvements-in-aspnet-core-8/ PS: I see the infamous blog post about how the TechEmpower benchmarks "cheat" so I'm glad OP is "doing their own research 😍". In fact, what we learn from some of the crazy benchmark code has gradually made it's way into the core product, improving the performance for the masses. This isn't a sprint, it's a marathon and its one of our "forever priorities" as part of the .NET charter. Our investment in performance for .NET directly saves Microsoft $$$ as we enable teams to do more with less. That is to say we will continue to improve performance as a top priority for the foreseeable future. More on reddit.com

Tl;dr?

More on reddit.com