Exploring C# 12: Latest Features and Enhancements

As developers, we constantly seek ways to improve our productivity and code quality. Microsoft's C# language has evolved significantly over the years, introducing new features with each iteration to streamline development processes and enhance functionality. The latest version, C# 12, continues this trend, bringing several exciting features and enhancements to the table. In this blog, we'll explore some of the niche, cutting-edge features of C# 12 that can revolutionize the way we write code.

Primary Constructors for Non-Record Types

One of the standout features in C# 12 is the introduction of primary constructors for non-record types. Until now, primary constructors were exclusive to record types, simplifying their syntax and making it easier to create immutable data structures. With C# 12, this convenience extends to all classes and structs.

Here's an example of how primary constructors work for a non-record type:

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

This syntax eliminates the need for explicit constructor definitions and property initializations, making the code more concise and readable. It's particularly useful for classes where immutability and simplicity are desired.

Interpolated String Handlers

String interpolation is a powerful feature in C#, making it easy to format strings. C# 12 introduces interpolated string handlers, providing more control over the performance and behavior of interpolated strings.

Consider a scenario where you have a logging method that should avoid string allocation if logging is disabled. With interpolated string handlers, you can achieve this efficiently:

public static void LogInfo([InterpolatedStringHandlerArgument("logLevel")] LogInterpolatedStringHandler handler)
{
    if (logLevel >= LogLevel.Info)
    {
        Console.WriteLine(handler.ToString());
    }
}

[InterpolatedStringHandler]
public ref struct LogInterpolatedStringHandler
{
    private StringBuilder _builder;

    public LogInterpolatedStringHandler(int literalLength, int formattedCount, LogLevel logLevel)
    {
        _builder = logLevel >= LogLevel.Info ? new StringBuilder(literalLength) : null;
    }

    public void AppendLiteral(string s) => _builder?.Append(s);
    public void AppendFormatted<T>(T value) => _builder?.Append(value);
}

This feature allows you to control the allocation and construction of interpolated strings, enhancing performance in scenarios where logging or string formatting is conditionally executed.

Default Interface Methods Enhancements

Default interface methods were introduced in C# 8, allowing interfaces to have method implementations. C# 12 enhances this feature by enabling interfaces to define static abstract members. This addition makes it possible to define a contract for static methods in interfaces, which can be particularly useful for generic programming.

Here's an example:

public interface IFactory<T>
{
    static abstract T Create();
}

public class Product : IFactory<Product>
{
    public static Product Create() => new Product();
}

This capability allows you to enforce the implementation of static methods in types that conform to an interface, opening new possibilities for design patterns and abstractions in your code.

Enhanced switch Expressions

C# 12 also brings enhancements to switch expressions, making pattern matching more powerful and expressive. One notable improvement is the ability to use relational patterns within switch expressions.

public string GetGrade(int score) => score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

This enhancement simplifies the code for scenarios involving range-based conditions, providing a cleaner and more intuitive way to handle complex logic.

Conclusion

C# 12 continues to push the boundaries of what developers can achieve with the language. The introduction of primary constructors for non-record types, interpolated string handlers, enhancements to default interface methods, and improved switch expressions are just a few examples of how C# 12 makes coding more efficient and expressive. By leveraging these new features, developers can write cleaner, more maintainable code, ultimately leading to more robust and performant applications. As always, staying up-to-date with the latest language features is crucial for any developer looking to keep their skills sharp and their codebase modern.