What's new in C# 12

In this blog post, we’ll delve into some of the standout features introduced in C# 12, including collection expressions, primary constructors, type aliasing, and default parameters for lambda expressions.

1. Collection Expressions: A Concise Way to Initialize Collections

One of the standout features introduced in C# 12 is collection expressions. This feature allows developers to initialize collections in a more concise and expressive manner. Prior to C# 12, initializing collections required multiple lines of code, leading to verbosity and decreased readability.

With collection expressions, initializing collections becomes a breeze. Consider the following example:

// Before C# 12
List<int> numbers = new List<int>
{
    1, 2, 3, 4, 5
};

// C# 12 Collection Expression
List<int> numbers = [1, 2, 3, 4, 5];

The concise syntax provided by collection expressions not only reduces the amount of boilerplate code but also enhances the overall readability of the code.

2. Primary Constructors for All Classes and Structs

C# 12 introduces a significant enhancement in the form of primary constructors for all classes and structs. Primary constructors streamline the process of initializing properties by allowing developers to define them directly in the constructor signature. This eliminates the need for separate property assignments within the constructor body.

// Before C# 12
public class Person
{
    public string Name { get; }
    public int Age { get; }

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

// C# 12 Primary Constructor
public class Person(string Name, int Age);

The primary constructor syntax not only reduces boilerplate code but also provides a clean and expressive way to define and initialize properties.

3. Syntax to Alias Any Type: Enhancing Code Readability

C# 12 introduces a syntax to alias any type, offering developers a powerful tool to enhance code readability. This feature allows developers to create concise and descriptive aliases for types, making the code more self-explanatory.

/ Before C# 12
Dictionary<string, List<int>> userScores = new Dictionary<string, List<int>>();

// C# 12 Type Alias
using UserScores = Dictionary<string, List<int>>;
UserScores userScores = new UserScores();

The type aliasing feature not only reduces the verbosity of type declarations but also contributes to improved code comprehension.

4. Default Parameters for Lambda Expressions: Flexibility and Simplicity

C# 12 introduces default parameters for lambda expressions, providing developers with greater flexibility when working with functions and delegates. This feature allows developers to define default values for parameters in lambda expressions, simplifying the code and reducing the need for repetitive boilerplate.

// Before C# 12
Func<int, int, int> add = (a, b) => AddNumbers(a, b);

// C# 12 Default Parameters
Func<int, int, int> add = AddNumbers;

int AddNumbers(int a, int b = 0) => a + b;

The introduction of default parameters for lambda expressions enhances the expressiveness of code and makes it more adaptable to different use cases.

Announcing C# 12

Conclusion

C# 12 introduces a set of compelling features that aim to simplify code, enhance expressiveness, and improve overall developer productivity. From concise collection expressions to primary constructors for all classes and structs, type aliasing, and default parameters for lambda expressions, these features contribute to a more modern and expressive C# programming experience. As developers continue to embrace these enhancements, the C# language evolves, providing a foundation for building robust and readable code in the ever-evolving landscape of software development