What's new in the .NET 11 runtime
.NET 11’s runtime changes, especially moving async/await machinery into the runtime for clearer stack traces and comparable performance, are being welcomed as a significant quality-of-life improvement for developers. Commenters contrast C# and .NET’s rich language features, tooling, and ecosystem—particularly for back-end and enterprise work—with Go and TypeScript, while also highlighting ongoing pain points like GUI cross‑platform options, mobile support, and Microsoft’s LTS/STS upgrade cadence and breaking changes. There is also interest in .NET’s potential as an AI- and agent-friendly platform, alongside concern over subtle behavioral shifts such as new decimal conversion semantics.
Runtime async changes & performance
- Big interest in .NET 11 moving async/await machinery into the runtime.
- Expected benefits: clearer live async call stacks in debuggers/profilers, more “natural” stack traces, potentially fewer hitches during cancellation.
- Clarified that exception stack traces already hid much of the compiler-generated state-machine frames; main win is for live debugging.
- Coroutines remain stackless; yielding becomes a runtime-aware operation, not just compiler rewriting.
C#/.NET vs Go and other languages
- Many compare .NET 11 + C# to Go for new projects:
- C# seen as more expressive: LINQ, attributes, richer generics, async/await, pattern matching, reflection, records, Span
, source generators. - Go praised for small binaries, simple syntax, fast compiles, strong stdlib, built-in HTTP server, goroutines, opinionated tooling.
- C# seen as more expressive: LINQ, attributes, richer generics, async/await, pattern matching, reflection, records, Span
- Native interop considered easier in .NET overall, though UTF‑16 vs UTF‑8 string marshalling is a pain point; UTF‑8 literals in C# 11 help.
- Opinions differ on concurrency: some prefer C# async/await for typical I/O, others prefer Go’s goroutines/channels; a subset argues F#+Hopac is nicer still.
- Several see Go’s limited feature set as a feature; others criticize its generics history, stringly-typed tags, and error-handling ergonomics.
Tooling, ecosystem, and deployment
- .NET praised for “batteries-included” ecosystem, robust libraries, and strong IDE tooling (Visual Studio, Rider, VS Code).
- Go credited with a better default single-binary deployment story; .NET single-file/AOT still uneven with some libraries.
- For enterprise apps, .NET is seen as fast, mature, and widely staffed; Go viewed as great for smaller tools and services.
Cross-platform, GUI, and mobile
- Ongoing frustration with Microsoft’s desktop UI story: many competing frameworks (WinForms, WPF, UWP, WinUI, MAUI), unclear long-term bets, and weak Linux/macOS support.
- Some recommend third-party frameworks like Avalonia for cross-platform GUIs; others stick to web or Electron/TypeScript for products.
- Mobile support via MAUI is viewed as not yet solid, especially on Linux.
Language evolution & sum types
- Excitement that C# 11 finally gets a form of sum types with exhaustive switch checking; still not full discriminated unions.
- A proposal for proper discriminated unions is under active design; some want easier “value object”/newtype support to approach F# ergonomics.
Decimal and numeric behavior changes
- .NET 11 changes conversions from floating-point to decimal to preserve the exact binary value, exposing non‑terminating decimals (e.g.,
(decimal)0.1now shows a long repeating-ish representation). - Some see this as a dangerous footgun for financial apps; others argue the previous magic rounding was wrong and that casting from double to decimal is bad practice anyway.
- Recommended approach in discussion: use
decimalconsistently and decimal literals (0.1m) rather than casting fromdouble/float.
Support model, version churn, and breaking changes
- .NET 11 is STS (2 years) vs even-numbered LTS releases (3 years); support timelines for .NET 10 and 11 end in 2028, with STS expiring slightly earlier.
- Some find STS/LTS distinctions confusing or weak compared to ecosystems like Java; others note it’s well-documented and similar to Node’s even/odd model.
- One strong criticism: yearly releases + breaking changes + short support windows effectively force constant upgrades and threaten long-term library stability.
- Counterpoints: old libraries targeting earlier TFMs still work; many apps happily remain on .NET 8/Framework; Microsoft isn’t literally forcing upgrades, though security tooling nudges you.
AI, agents, and “AI-native” .NET
- Several argue C#/.NET is an excellent “AI-era” stack:
- Stable toolchain, strong typing, rich analyzers (Roslyn), good docs, predictable patterns.
- Agents can leverage tools like
csharpreplinjected into running processes/DI to inspect and modify live state.
- Others lament that, in practice, AI tooling and ecosystems favor Python, Rust, and TypeScript, and that C# failed to gain mindshare in AI despite Microsoft’s efforts.
- F# is reported to work surprisingly well with AI code generation; good, idiomatic F# backends have been built largely by agents.
Perception, culture, jobs, and IDEs
- Many feel C#/.NET is underappreciated due to legacy Windows-only perceptions, past tech deprecations (WCF, Silverlight, AppFabric), and mistrust of Microsoft.
- Despite that, there’s lots of “dark matter” C# in enterprises (e.g., healthcare, ERPs); work is often stable but can feel boring.
- For editors/IDEs on Linux/macOS, Rider and VS Code are the main recommendations; some still use full Visual Studio on Windows.
- A number of participants say modern LLMs plus simpler editors reduce the need for heavyweight refactoring tools.