What is new .C# 12 ? Primary Constructors, Collection Expressions, Inline Arrays

3 min readMar 22, 2024

C# continues to evolve, and with version 12, it brings a suite of features designed to streamline development and boost performance. Let’s delve into some of these exciting new additions and see how they can transform our coding practices.

I have just published course — .NET 8 Microservices: C# 12, DDD, CQRS, Vertical/Clean Architecture.

Primary Constructors — Simplifying Class Definitions

C# 12 extends the convenience of primary constructors beyond just record types, allowing parameters to be in scope for the entire class body. This change simplifies class definitions and ensures parameters are definitely assigned, fostering cleaner and more concise code.

public class Person(string name, int age)
{
    public string Name => name;
    public int Age => age;
}

Collection Expressions — Streamlining Collections

Say goodbye to the verbose syntax for initializing collections. C# 12 introduces collection expressions, enabling a more succinct way to define common collections, enhancing readability, and making collection manipulation a breeze.

// Before C# 12
var numbers = new List<int> { 1, 2, 3, ...otherNumbers };

// With C# 12
var numbers = [1, 2, 3, ..otherNumbers];

Inline Arrays — Boosting Performance

For those who crave efficiency, inline arrays in C# 12 offer a way to create fixed-size arrays within struct types. This feature is a boon for optimizing memory layouts and enhancing runtime performance, particularly in high-performance scenarios.

public struct Buffer
{
    public Span<int> InlineArray => MemoryMarshal.CreateSpan(ref _array[0], 10);
    private int[] _array;
}

Optional Parameters in Lambda Expressions — Adding Flexibility

C# 12 brings the convenience of optional parameters to lambda expressions, aligning them with the flexibility found in method definitions. This addition opens up new possibilities for lambda expressions, making them even more versatile.

Func<int, int, int> add = (x, y = 1) => x + y;
Console.WriteLine(add(5)); // Outputs 6

ref readonly Parameters — Enhancing Memory Efficiency

The introduction of ref readonly parameters in C# 12 marks a significant step forward in memory optimization, especially when dealing with large data structures. This feature ensures data can be passed efficiently without the risk of modification.

public void ProcessLargeData(in LargeData data)
{
    // Processing data securely and efficiently
}

Alias Any Type — Expanding Usability

C# 12 expands the using alias directive to encompass any type, offering the ability to create semantic aliases for complex types such as tuples, arrays, and pointer types, thus enhancing code clarity and maintainability.

using Coordinate = System.ValueTuple<int, int>;
Coordinate location = (10, 20);

Embracing C# 12 in Microservices

These new features in C# 12, particularly primary constructors, collection expressions, and inline arrays, will be instrumental in our journey through microservices development. They promise to simplify our code, enhance performance, and make our applications more efficient and expressive.

Stay tuned as we incorporate these cutting-edge features into our microservices applications, pushing the boundaries of what’s possible with C#.