C# 12-14 & .NET 9-10: Modern Features Deep Dive

Modern C# and .NET are evolving rapidly. With C# 12, 13, and 14 (preview) alongside .NET 9 and 10, Microsoft introduces features that significantly reduce boilerplate, improve performance, and enable new programming patterns. Whether you're building web APIs, cloud-native services, or desktop applications, these features can make your code cleaner, safer, and faster.

Consider a typical enterprise application: you have DTOs, service classes, and collection manipulations. In older C#, you'd write verbose constructors, manual property assignments, and repetitive collection initializations. With primary constructors, collection expressions, and interceptors, you can cut code by 30-50% while improving readability.

But with great power comes great responsibility. Some features, like interceptors, are experimental and require careful use. This tutorial will guide you through each feature with production-ready examples, common pitfalls, and real-world debugging scenarios. By the end, you'll be able to leverage these modern features confidently in your .NET projects.

Primary Constructors in C# 12

Primary constructors allow you to declare constructor parameters directly in the class declaration. This reduces boilerplate for simple classes that just store data. However, they are not just syntactic sugar—they capture parameters as fields that can be used throughout the class.

Consider a traditional class:

```csharp public class Person { public string Name { get; } public int Age { get; }

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

With primary constructors, you can write:

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

Production insight: Always validate parameters in the constructor body if needed. Primary constructors do not add null checks automatically.

public class Employee(string firstName, string lastName, int salary)
{
    public string FullName => $"{firstName} {lastName}";
    public int Salary { get; set; } = salary;

    // Additional constructor
    public Employee(string firstName, string lastName) : this(firstName, lastName, 0) { }

    public void Display()
    {
        Console.WriteLine($"{FullName} earns {Salary}");
    }
}

// Usage
var emp = new Employee("John", "Doe", 50000);
emp.Display(); // Output: John Doe earns 50000

Collection Expressions in C# 12

Collection expressions provide a concise syntax to create common collection types like arrays, lists, and spans. They use square brackets [] and support spread operator .. to include elements from other collections.

Examples:

```csharp // Array int[] numbers = [1, 2, 3, 4, 5];

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

// Span Span<char> span = ['H', 'e', 'l', 'l', 'o'];

// Spread operator int[] moreNumbers = [..numbers, 6, 7, 8]; ```

They work with any type that has a CollectionBuilderAttribute or implements IEnumerable and has an Add method.

Performance: Collection expressions are optimized by the compiler to use the most efficient initialization pattern (e.g., List<T> with initial capacity).

Production insight: Be careful with spread operator on null collections—it will throw NullReferenceException.

using System;
using System.Collections.Generic;

var numbers = new[] { 1, 2, 3 };
var moreNumbers = [..numbers, 4, 5]; // Spread

List<string> fruits = ["apple", "banana", "cherry"];
var allFruits = [..fruits, "date"];

Console.WriteLine(string.Join(", ", moreNumbers));
Console.WriteLine(string.Join(", ", allFruits));

Interceptors in C# 12 (Experimental)

Interceptors allow you to replace a method call at compile time with a call to your own code. This is an experimental feature (requires InterceptorsPreview flag) and is intended for advanced scenarios like AOP, logging, or profiling.

Example:

```csharp // Target method public static void Log(string message) => Console.WriteLine($"Original: {message}");

// Interceptor public static void InterceptLog(string message) => Console.WriteLine($"Intercepted: {message}");

// Apply attribute [InterceptsLocation("Program.cs", 10, 5)] // file, line, column public static void InterceptLog(string message) => Console.WriteLine($"Intercepted: {message}"); ```

Production insight: Use interceptors sparingly; prefer source generators for robust code generation.

// Requires <InterceptorsPreview>true</InterceptorsPreview> in csproj
using System.Runtime.CompilerServices;

public static class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"Original: {message}");
    }
}

public static class Interceptor
{
    [InterceptsLocation("Program.cs", 7, 9)] // line 7, column 9
    public static void InterceptLog(string message)
    {
        Console.WriteLine($"Intercepted: {message}");
    }
}

// Program.cs line 7
Logger.Log("Hello"); // This call is intercepted

Required Members in C# 11 and Beyond

The required modifier forces callers to initialize a property or field during object creation. This is useful for ensuring that essential data is provided without relying on constructor parameters.

Example:

```csharp public class Person { public required string Name { get; init; } public int Age { get; set; } }

// Usage var person = new Person { Name = "Alice" }; // Age is optional // var invalid = new Person(); // Error: Name is required ```

required works with both init and set accessors. It is enforced at compile time.

Production insight: Combine required with primary constructors for a robust initialization pattern.

public class Configuration
{
    public required string ConnectionString { get; init; }
    public int TimeoutSeconds { get; set; } = 30;
}

// Correct usage
var config = new Configuration { ConnectionString = "Server=...;" };

// Compiler error if missing
// var bad = new Configuration(); // CS9035: Required member 'ConnectionString' must be set

Inline Arrays in C# 12

Inline arrays allow you to create fixed-size arrays on the stack without heap allocation. They are useful for high-performance scenarios like interop with native code or SIMD operations.

Syntax:

```csharp [InlineArray(10)] public struct Buffer { private int _element0; // Must have a single field }

// Usage var buffer = new Buffer(); for (int i = 0; i < 10; i++) buffer[i] = i; ```

Production insight: Use inline arrays only when performance is critical and you need stack allocation. For most cases, use Span<T> or arrays.

using System.Runtime.CompilerServices;

[InlineArray(5)]
public struct IntBuffer
{
    private int _element;
}

var buffer = new IntBuffer();
buffer[0] = 10;
buffer[1] = 20;
Console.WriteLine(buffer[0] + buffer[1]); // 30

New Lock Statement in C# 13

C# 13 introduces a new Lock type that provides better performance and semantics for synchronization. The System.Threading.Lock class is designed to replace Monitor-based locking.

Example:

```csharp using System.Threading;

Lock myLock = new();

void ThreadSafeMethod() { lock (myLock) { // Critical section } } ```

Production insight: Migrate from lock(this) or lock(typeof(MyClass)) to Lock instances to avoid deadlocks and improve clarity.

using System.Threading;

public class Counter
{
    private readonly Lock _lock = new();
    private int _count;

    public void Increment()
    {
        lock (_lock)
        {
            _count++;
        }
    }

    public int GetCount()
    {
        lock (_lock)
        {
            return _count;
        }
    }
}

var counter = new Counter();
Parallel.For(0, 1000, _ => counter.Increment());
Console.WriteLine(counter.GetCount()); // 1000

Performance Improvements in .NET 9-10

.NET 9 and 10 bring significant performance enhancements: - JIT improvements: Better inlining, loop optimizations, and PGO (Profile-Guided Optimization). - GC improvements: Reduced pause times and better memory management. - New APIs: System.Numerics vectorization, System.Text.Json source generator enhancements. - AOT compilation: Native AOT for smaller, faster startup.

Example: Using Vector<T> for SIMD operations:

```csharp using System.Numerics;

float[] data = { 1, 2, 3, 4 }; var vector = new Vector<float>(data); var result = vector + vector; // Element-wise addition ```

Production insight: Enable PGO by setting <TieredPGO>true</TieredPGO> in your project file for better runtime performance.

using System.Diagnostics;
using System.Numerics;

var sw = Stopwatch.StartNew();
float[] array = new float[1000000];
for (int i = 0; i < array.Length; i++) array[i] = i;

// SIMD sum
Vector<float> sumVector = Vector<float>.Zero;
for (int i = 0; i < array.Length; i += Vector<float>.Count)
{
    var v = new Vector<float>(array, i);
    sumVector += v;
}
float sum = 0;
for (int i = 0; i < Vector<float>.Count; i++) sum += sumVector[i];
sw.Stop();
Console.WriteLine($"Sum: {sum}, Time: {sw.ElapsedMilliseconds}ms");