What's New in C# 12: Complete Guide with Real Examples and Business Cases

The .NET ecosystem took another giant leap forward. With the latest release of C# alongside .NET 8, developers are presented with a suite of new features designed to simplify code architecture, enhance performance, and improve team productivity. This comprehensive guide will walk you through the most impactful novelties of C# 12, offering real-world examples and exploring how these changes can be applied in enterprise environments.

Why C# 12 Matters for Enterprise Applications

Enterprise applications demand maintainability, clarity, and performance. New language features often bridge the gap between boilerplate code and elegant business logic. C# 12 focuses heavily on making the language less verbose and more expressive. From primary constructors for classes and structs to collection expressions, these updates reduce the cognitive load on developers and make code reviews faster and more focused on business constraints rather than syntax details.

By upgrading your technology stack, organizations ensure that their engineering teams are using the most productive tools available, which directly translates to faster time-to-market for new features and lower maintenance costs. Moreover, the tight integration with modern frameworks ensures that your backend services remain resilient and highly available.

Primary Constructors for All Classes and Structs

One of the most anticipated features is the extension of primary constructors from records to all classes and structs. Previously, developers had to explicitly define a constructor, declare private fields, and assign the constructor parameters to those fields. This boilerplate code is now a thing of the past.

How It Works

You can now add parameters directly to the class or struct declaration. These parameters are available throughout the body of the class, allowing you to easily initialize properties, fields, or use them directly in methods.

public class DataService(ILogger<DataService> logger, IRepository repository)
{
    public void ProcessData()
    {
        logger.LogInformation("Processing data started.");
        var data = repository.GetData();
        // Business logic here
    }
}

This syntax is incredibly useful in Dependency Injection (DI) scenarios, which are ubiquitous in modern ASP.NET Core applications. By eliminating the repetitive assignment of injected services to private readonly fields, the code becomes much cleaner and less prone to copy-paste errors.

Collection Expressions

C# 12 introduces a new, concise syntax for creating common collections. Collection expressions provide a uniform way to initialize arrays, lists, and span types, replacing the different syntaxes previously required for each.

A Modern Approach to Collections

Instead of using `new int[] { 1, 2, 3 }` or `new List<int> { 1, 2, 3 }`, you can now use a unified array-like literal syntax. Furthermore, the new spread operator (`..`) makes it exceptionally easy to concatenate or inline existing collections into a new one.

// Initializing a list
List<string> names = ["Alice", "Bob", "Charlie"];

// Using the spread operator to combine collections
int[] firstBatch = [1, 2, 3];
int[] secondBatch = [4, 5, 6];
int[] allData = [.. firstBatch, 99, .. secondBatch];

In enterprise systems that frequently map data between DTOs and domains, or build complex JSON structures, collection expressions significantly streamline the code. They also allow the compiler to optimize the underlying memory allocation, improving performance automatically without developer intervention.

Inline Arrays

Performance-critical applications, such as high-frequency trading systems or low-latency microservices, benefit immensely from minimizing heap allocations. C# 12 introduces inline arrays, enabling developers to create fixed-size arrays inside a struct without relying on `unsafe` code blocks.

Improving Memory Locality

By storing multiple values directly within the struct's memory layout, you avoid the overhead of a separate object allocation and subsequent garbage collection. The syntax involves applying the `[InlineArray(length)]` attribute to a struct containing a single field.

[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer10<T>
{
    private T _element0;
}

// Usage
var buffer = new Buffer10<int>();
for (int i = 0; i < 10; i++)
{
    buffer[i] = i * 2;
}

While this feature is primarily used by library authors and framework developers, enterprise architects building high-throughput services can leverage it to optimize critical data processing pipelines, ensuring hardware caches are utilized efficiently.

Default Lambda Parameters

Lambdas have been a cornerstone of C# since LINQ was introduced, but they lacked support for default parameters—until now. C# 12 allows you to provide default values for lambda expressions, making them as versatile as standard local functions or methods.

Simplifying Functional Code

This is particularly useful when defining inline strategies or callback functions that have optional configuration parameters. It removes the need for overloading or manual null checks.

var calculateDiscount = (decimal price, decimal rate = 0.10m) => price * (1 - rate);

var standardPrice = calculateDiscount(100m); // Uses 10%
var specialPrice = calculateDiscount(100m, 0.20m); // Uses 20%

Alias Any Type

The `using` alias directive has been expanded in C# 12. You can now alias almost any type, not just named types. This includes tuple types, pointer types, and array types, allowing for highly readable and domain-specific code.

Enhancing Readability with Tuples

Working with complex tuples often results in unreadable signatures scattered throughout the codebase. By aliasing the tuple, you create a semantic name that improves domain clarity.

using Coordinates = (double Latitude, double Longitude);
using UserRecord = (int Id, string Name, string Email);

public class LocationService
{
    public Coordinates GetTargetLocation() => (40.7128, -74.0060);
}

This feature bridges the gap between lightweight tuples and full-fledged records, providing the semantics of a named type with the minimal overhead of a tuple.

Conclusion

C# 12 continues the tradition of making the language more expressive, safe, and performant. By adopting these new features, enterprise teams can write code that is not only faster to execute but also easier to read, review, and maintain.

The introduction of primary constructors eliminates repetitive DI setup, while collection expressions modernize how we handle data aggregates. Meanwhile, advanced features like inline arrays cater to the high-performance needs of modern cloud services. To stay competitive, technical leaders should encourage their teams to evaluate and integrate these features into their coding standards.