In the world of C#, classes and structs are fundamental building blocks for creating custom data types. While these constructs already offer a mechanism for initializing objects, C# 12 introduced a new feature called primary constructors that simplifies and streamlines the process of creating and initializing objects.

Understanding Primary Constructors

Primary constructors are essentially a more concise way of defining constructors that directly initialize the object's properties. With primary constructors, you can define the constructor parameters within the class declaration itself, making the syntax more intuitive and readable.

Declaring Primary Constructors

To declare a primary constructor, simply place the constructor parameters within parentheses immediately after the class or struct name. For example, consider a class for representing points on a coordinate plane:

public class Point(int x, int y)
{
}

In this example, the Point class has a primary constructor that takes two integer parameters, x and y, representing the coordinates of the point. These parameters are directly accessible within the class body using their names.

Using Primary Constructor Parameters

Once you've declared a primary constructor, you can use its parameters to initialize the object's properties. For instance, to create a point with coordinates (10, 20), you can simply instantiate the class:

var point = new Point(10, 20);

This code creates a new Point object and assigns the values 10 to its x property and 20 to its y property.

Benefits of Primary Constructors

Primary constructors offer several advantages over traditional constructor declarations:

1. Simplified Syntax: Primary constructors reduce boilerplate code and make the constructor declaration more concise.

2. Easier Readability: The syntax of primary constructors makes the code more readable and easier to understand, especially for beginners.

3. Improved Maintainability: Primary constructors promote code maintainability by reducing the need for repetitive code snippets.

Primary Constructors for Dependency Injection

Primary constructors can be particularly useful in dependency injection (DI) scenarios. DI is a design pattern that allows you to decouple the creation of objects from their usage, making your code more flexible and testable. With primary constructors, you can inject dependencies directly into the constructor parameters, making it easier to manage object dependencies.

Consider a class Person that requires a Logger object to log messages:

public class Person(ILogger logger) {
    private ILogger Logger { get; } = logger;
}

Primary Constructors for Inheritance

Primary constructors also make it easier to define and use inheritance hierarchies. Inheriting from a class with a primary constructor allows you to initialize the inherited properties from the base class constructor, simplifying the initialization process.

Consider a Point class representing points on a two-dimensional plane and a Point3D class representing points on a three-dimensional plane:

public class Point(int x, int y)
{
    public int X { get; } = x;
    public int Y { get; } = y;
}

public class Point3D(int x, int y, int z) : Point(x, y)
{
    public int Z { get; set; } = z;
}

The Point3D class inherits from Point and initializes its X and Y properties using the base class constructor. It also declares an additional property, Z, to represent the third dimension.

Conclusion

Primary constructors are a welcome addition to C# 12, providing a more straightforward and concise way to define constructors and initialize object properties. By simplifying the constructor declaration, primary constructors make C# code more readable, maintainable, and beginner-friendly.