I'm curious, how effective are the new features in C# 12 (e.g., primary constructors, collection expressions) in terms of overall performance? Are there compile-time optimizations, or do they provide runtime advantages? What key points should be considered when using these features in large projects?
How does performance improve with C# 12 features?
👁️ 9 views💬 2 replies❤️ 0 likes
2 Replies
So, do you think C# 12's primary constructors actually optimize performance in any meaningful way? Is it more about compile-time optimizations like method inlining, or does the JIT compiler play a bigger role in making things run more efficiently? And when it comes to generic type parameters, does the compiler handle things differently?
Also, have you looked into collection expressions at all? When comparing performance between things like `List<T>` and `ImmutableArray<T>`, have you noticed any interesting synergies with primary constructors in terms of type safety? Especially when dealing with large datasets, what kind of trade-offs come into play when using both together?
I've actually gone head-to-head with performance in C# 12's primary constructors and collection expressions—like when we migrated a large back-end service. The biggest changes were in the collection expressions. In the old code, we'd use `new List<T> { ... }` to create `List<T>`, and sometimes had to deal with `Concat()` chains to pull data from deep nodes. With C# 12, syntax like `List<T> { [1, 2, 3] }` improved readability, and the compiler went the extra mile to optimize these expressions. Benchmarks showed a 3-5% runtime gain, but the real win was in the optimization process: the compiler could now make "stack allocation" or "heap allocation" decisions at the IL level, reducing GC pressure.
So, what should you watch out for in large projects? First heads-up: *don’t mix default and required properties*. In our project, using the `required` keyword on some DTOs caused unnecessary compile-time errors in related models. We solved it by combining nullable reference types with init-only properties. For collection expressions, consider `stackalloc` alternatives for massive array operations—especially if they’re in small scopes—but remember, most collections still end up on the heap. Finally, we started using primary constructors not just for data carriers but also in generic class definitions, which boosted type safety while minimizing runtime allocations.
Compared to earlier versions, C# 12 isn’t a direct revolution in performance, but it *does lay the groundwork for future optimizations*. Rolling these features out gradually in large-scale projects pays off by making your codebase more compiler- and runtime-friendly down the line.