Primary Constructors in C# 12: Less Boilerplate, More Focus

C# 12 introduces primary constructors, which simplify the definition of constructors in classes and structs, making the code more concise and easier to read. This is especially beneficial for scenarios involving dependency injection or simple property initialization. To understand the advantages of primary constructors, let's first explore how constructor definitions typically worked before C# 12, and then compare this with the new syntax.

Standard Approach (Pre-C# 12)

In earlier versions of C#, creating a constructor for a class often involved multiple steps. For example, when you need to initialize fields with constructor parameters, you had to:

• Declare private fields to store the values.
• Define a constructor that accepts parameters.
• Assign those parameters to the fields inside the constructor.
• Expose those fields through read-only properties.

Here's how this looked in code:

public class Product
{
    private readonly int _id;
    private readonly string _name;

    // Constructor takes parameters
    public Product(int id, string name)
    {
        _id = id;  // Assign parameters to fields
        _name = name;
    }
 
    public int Id => _id;
    public string Name => _name;    
}        

This is a common pattern in object-oriented programming, but it can become repetitive and boilerplate-heavy, especially when dealing with many dependencies or properties.

Primary Constructors (C# 12)

With primary constructors:

• The constructor parameters (value, name) are declared directly in the class or struct declaration.
• These parameters are in scope throughout the class, allowing you to use them directly.
• You can directly use the constructor parameters to initialize read-only properties.
• The compiler implicitly generates the necessary private fields and constructor logic.

public class Product(int id, string name)
{
    public int Id => id;
    public string Name => name;
}
        

Comparison and Benefits of Primary Constructors

1. Reduced Boilerplate

The primary constructor reduces the need for repetitive code, making your classes more concise. You no longer have to declare private fields and assign constructor parameters to them. The compiler takes care of the behind-the-scenes details.

Traditional Approach vs. Primary Constructor

2. Improved Readability

With primary constructors, the constructor parameters are directly visible in the class declaration, making it easier to understand a class's dependencies or required data at a glance. This reduces the need to search through the constructor body for initialization logic.

3. Simplified Dependency Injection

Primary constructors shine when used with dependency injection. For example, if your class relies on services or repositories, you can inject them directly via the primary constructor. This results in clear and simple definitions for classes with external dependencies.

public class ProductService(ILogger<ProductService> logger, IProductRepository repository)
{
    public void HandleProduct(int productId)
    {
        logger.LogInformation("Fetching product with ID: {ProductId}", productId);
        var product = repository.GetProductById(productId);
     }
}        

4. Concise Record and Struct Definitions

Primary constructors are especially effective when working with records and structs. Records are designed for immutable data containers, and primary constructors align perfectly with this pattern.

public record Product(int Id, string Name);        

Considerations

While primary constructors simplify code, there are some considerations:

• Complex Initialization: If the constructor involves more complex logic or validation, you may still prefer to use a traditional constructor alongside the primary constructor.
• Field Names: The compiler-generated backing fields are not accessible by name. If you need to control the field name, you should use the traditional method.
• Compatibility: Existing codebases using the traditional approach will need to be updated manually if you want to take advantage of primary constructors.

C# 12's primary constructors significantly improve code conciseness and readability, making them ideal for simple property initialization and dependency injection. By reducing boilerplate code and streamlining class definitions, they help developers write cleaner, more maintainable code. However, they are not a one-size-fits-all solution. For complex initialization logic or when specific field names are needed, the traditional constructor approach is still relevant.