C# : 12.0 : Primary constructor

Introduction

In C# 12.0, the introduction of the "Primary Constructor" simplifies the constructor declaration process. Before delving into this concept, let's revisit constructors.

A constructor is a special method in a class with the same name as the class itself. It's possible to have multiple constructors through a technique called constructor overloading. 

By default, if no constructors are explicitly defined, the C# compiler generates a default constructor for each class.

Now, in C# 12.0, the term "Primary Constructor" refers to a more streamlined way of declaring constructors. This feature enhances the clarity and conciseness of constructor declarations in C# code.

Lets see an simple example code, which will be known to everyone.

public class Version
{
    private int _value;
    private string _name;
    public Version(int value, string name)
    {
        _name = name;
        _value = value;
    }
    public string VersionName
    {
        get
        {
            return $"{_value} {_name}";
        }
    }
}

C#

In the above example, we have a straightforward class with two fields, _value and _name, and a parameterized constructor. 

Additionally, there's a public method that returns an immutable string value, combining the name and value.

In C# 12.0, the code can be simplified with fewer lines. The primary constructor, denoted by the class name, is introduced along with another constructor that has only one parameter. 

This showcases the elegance and brevity brought by the new primary constructor feature.

public class Version(int value, string name)
{
    public Version(int value) : this(value, "None") // call primary constructor in every  constructor
    {
    }

    public string VersionName
    {
        get
        {
            return $"{value}. {name}";
        }
    }
}

C#

The syntax in the above example might seem a bit unconventional when compared to the traditional constructor declaration. 

However, it aligns with the new features in C# , particularly the Record type, which shares a similar syntax.

Let's delve into the syntax through the provided code snippet

public record Version2(int Value, string Name)
{
    public string VersionName
    {
        get
        {
            return $"{Value} {Name}";
        }
    }
}

C#

Here created a record with similar parameters value and name addon with Version Name returning a string. 

Both record classes can be called with object instance. Whilst record Properties are created with camel case and class properties are with lowercase as usual.

var x = new Version2 (1, "Test");
Console.WriteLine (x.Value);
Console.WriteLine(x. Name);
Console.WriteLine(x. VersionName);

var y= new Version (2, "Test 2");
Console.WriteLine(y.value);
Console.WriteLine(y. name);
Console.WriteLine(y. VersionName);

C#

Primary constructor we have mutable fields. 
In record case, we have immutable properties.