Announcing .NET 11
Announcing .NET 11 prompts wide-ranging reactions on the state of C# and the modern .NET ecosystem, from enthusiasm about runtime-managed async/await, better stack traces, performance gains and new language features like union types to frustration over Microsoft’s fragmented desktop UI story and short support windows with breaking changes. Many compare .NET to Go, Rust, TypeScript and Python, arguing that .NET now offers a highly expressive language, strong tooling, NativeAOT, and a “batteries-included” ecosystem that shines for back-end and enterprise workloads, even as Go retains advantages in deployment simplicity and CLI tooling. Others note cultural and ecosystem concerns—such as commercializing popular OSS libraries and lingering mistrust of Microsoft—but still see .NET as a powerful, underappreciated platform that pairs especially well with AI-assisted development.
Runtime & async changes
- Big interest in the new runtime-based async/await: clearer async stack traces, fewer allocations, and better debugger/profiler views.
- Exception stack traces already hid most async plumbing; main win is live call stacks and profiling.
- Coroutines remain stackless; yielding is now a runtime-aware operation rather than purely compiler-generated state machines.
- Some wonder how this interacts with custom async builders; long‑term impact is unclear.
C#/.NET vs Go and other languages
- Many prefer C# over Go for new systems when both are viable:
- C# is more expressive (LINQ, attributes, records, advanced generics, pattern matching, reflection, Span
, etc.). - Richer, more “batteries-included” ecosystem and frameworks, especially for web, data access, and enterprise apps.
- Native interop is seen as stronger in .NET, with new UTF‑8 literals helping FFI.
- C# is more expressive (LINQ, attributes, records, advanced generics, pattern matching, reflection, Span
- Go’s advantages: very simple language, fast compiles, single static binaries, solid stdlib, good for CLIs and small services.
- Some argue Go’s limited feature set and past generics story are a dealbreaker; others see minimalism and backward compatibility as core features.
Tooling, IDEs, and cross‑platform
- Tooling is repeatedly praised: Visual Studio, JetBrains Rider, VS Code + language server; strong debugging, profiling, and remote debugging.
- Some now lean on LLMs plus lightweight editors instead of heavy IDE refactoring.
- Cross‑platform server‑side support (Linux containers, Kestrel) is considered mature; desktop/mobile story is messy:
- MAUI: improving, used successfully in production, but still seen as immature and weak on Linux.
- Alternatives like Avalonia get positive mentions.
- Long‑running confusion and churn around WinForms/WPF/WinUI/UWP hurt trust.
Versioning, support, and breaking changes
- .NET 11 is STS; .NET 10 is LTS. Pattern: even = LTS, odd = STS; 2‑year vs 3‑year support.
- One camp: upgrades from .NET 6+ are usually trivial, and keeping dependencies updated regularly is manageable.
- Another camp: strongly criticizes frequent EOL plus documented breaking changes, arguing this undermines long‑term library stability and backward compatibility culture.
Numeric behavior & performance
- Notable breaking change: casting from floating‑point to
decimalis now more precise/exact, exposing non‑decimal representations (e.g.,(decimal)0.1no longer prints as “0.1”). - Many say you shouldn’t cast from double/float to decimal anyway; use decimal literals (
0.1m) and explicit rounding. - Several emphasize modern .NET (with JIT or NativeAOT) is highly performant; claims that it is “slow” or “not compiled to machine code” are disputed.
Ecosystem, OSS, and perception
- C#/.NET is viewed as underappreciated, partly due to historic “Windows‑only” and Microsoft baggage.
- Strong praise for stability, documentation, Roslyn analyzers, source generators, and suitability for AI‑assisted/agentic development.
- Concerns about .NET OSS culture: popular libraries going commercial or adding “maintenance fees” after becoming de‑facto standards creates mistrust.
- Community culture sometimes skewed toward “enterprisey” over‑engineering and older design‑pattern dogma; nonetheless many report very positive day‑to‑day experience with modern .NET.