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:
Simplified Syntax: Primary constructors reduce boilerplate code and make the constructor declaration more concise.
Easier Readability: The syntax of primary constructors makes the code more readable and easier to understand, especially for beginners.
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.
Top comments (2)
Hamid Molareza, great post !
Very useful, thanks for sharing
I'm glad that it was useful for you. ❤️