Exploring Primary Constructors in C# 12 and .NET 8

by

With the release of .NET 8 and C# 12, developers have been introduced to several new features that enhance the development experience. One of the most exciting additions is the primary constructor for classes. This blog post will provide an in-depth look at primary constructors, their benefits, and how to use them effectively in your projects.

What Are Primary Constructors?

Primary constructors are not entirely new to C#. They have been available for record types, but with C# 12, the primary constructor can now be used with classes and structures as well. A primary constructor allows you to define constructor parameters directly in the class declaration, making the code more concise and readable.

Setting Up Your Project

To get started, ensure you have .NET 8 and the latest version of Visual Studio 2022. When creating a new project, you can select .NET 8 as the framework.

Using Primary Constructors with Classes

Let’s dive into an example. Traditionally, you would define a class and its constructor like this:

public class Test
{
    public string Name { get; }

    public Test(string name)
    {
        Name = name;
    }
}

With primary constructors, this can be simplified:

public class Test(string Name)
{
    public string Name { get; } = Name;
}

In this example, the Name property is directly attached to the class declaration. This makes the class definition cleaner and more concise.

Benefits of Primary Constructors

  1. Conciseness: Reduces boilerplate code by eliminating the need to separately declare properties and their initialization in the constructor.
  2. Readability: Improves the readability of class definitions by keeping all necessary information in one place.
  3. Consistency: Helps maintain a consistent structure for data models and other classes.

Using Primary Constructors in Methods

You can still define methods within the class to utilize properties initialized via the primary constructor:

public class Test(string Name)
{
    public string Name { get; } = Name;

    public void PrintName()
    {
        Console.WriteLine(Name);
    }
}

// Usage
var test = new Test("Hello World");
test.PrintName(); // Outputs: Hello World

Handling Multiple Constructors

The primary constructor feature can be combined with other constructors, but there are some rules to follow. For example, if you declare another constructor, it must call the primary constructor:

public class Test(string Name)
{
    public string Name { get; } = Name;

    public Test(string name, string address) : this(name)
    {
        // Additional initialization
    }
}

Using Default Values

You can also use default values for primary constructor parameters:

public class Test(string Name = "Default Name")
{
    public string Name { get; } = Name;
}

// Usage
var test = new Test();
Console.WriteLine(test.Name); // Outputs: Default Name

Inheritance and Primary Constructor

The primary constructor works seamlessly with inheritance. Here’s an example:

public class BaseTest(string Name)
{
    public string Name { get; } = Name;
}

public class ChildTest(string Name, string Address) : BaseTest(Name)
{
    public string Address { get; } = Address;
}

// Usage
var childTest = new ChildTest("John Doe", "123 Main St");
Console.WriteLine(childTest.Name);    // Outputs: John Doe
Console.WriteLine(childTest.Address); // Outputs: 123 Main St

Conclusion

The primary constructor feature in C# 12 and .NET 8 provides a powerful and concise way to define classes, making your code cleaner and more maintainable. Whether you are initializing properties, handling inheritance, or setting default values, the primary constructor streamlines the process and enhances readability.

If you found this guide helpful, please head over to my YouTube channel, give it a thumbs up, and subscribe to our channel for more insights and tutorials. Thank you for reading!

Related Videos from my YouTube Channel: