C# Init Keyword (How It Works For Developers)

The init keyword in C# 9.0 introduced a new way of defining class properties for creating immutable objects. In earlier versions of C#, properties were typically used to get and set accessors to read from and write to object fields. However, with init, you can make writeable properties only during object initialization and remain read-only afterward.

This tutorial will explore using the C# init keyword with practical examples and scenarios with the IronPDF library. You'll also learn about the critical differences between traditional property setters (set) and the new init-only setters.

Basic Example of the Init Keyword

Let's start with a basic example:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
var person = new Person
{
    FirstName = "Iron",d
    LastName = "Dev"
};
// person.FirstName = "Jane";  // This will give a compile-time error.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
var person = new Person
{
    FirstName = "Iron",d
    LastName = "Dev"
};
// person.FirstName = "Jane";  // This will give a compile-time error.

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class
Private person = New Person With {
	.FirstName = "Iron",
	d LastName = "Dev"
}
' person.FirstName = "Jane";  // This will give a compile-time error.

In this example, FirstName and LastName are marked as init-only property. This means they can be assigned only during an object initializer. After the object is created, attempting to change the values will cause a compile-time error.

Why Use the Init Keyword?

The main reason for using the init keyword is to make object properties immutable after Initialization. Traditionally, you could mark properties as read-only to achieve immutability. However, you would often need a constructor that accepts all necessary values to set the fields, which can lead to constructor boilerplate code. With init, you can achieve the same goal using object initializers without writing long constructors.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}
var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}
var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	' Without using constructor boilerplate for property initialization
End Class
Private person = New Person With {
	.FirstName = "John",
	.LastName = "Doe"
}

Object Initialization with Init-Only Properties

Using init works seamlessly with object initializers. Instead of relying on constructors to set values, you can define the properties you need directly while creating an object.

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}
var point = new Point { X = 10, Y = 20 };
// point.X = 30;  // This will throw a compile-time error

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}
var point = new Point { X = 10, Y = 20 };
// point.X = 30;  // This will throw a compile-time error

Public Class Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Class
Private point = New Point With {
	.X = 10,
	.Y = 20
}
' point.X = 30;  // This will throw a compile-time error

This creates a simple, immutable object of type Point. Notice that the values for X and Y are set at Initialization and can't be modified later.

Mixing init with Constructors

Although the primary use case for init is object initialization via object initializers, you can still use a constructor if needed. This is particularly useful when enforcing specific property values during object creation.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

You can use both constructors and init properties together. This approach has more flexibility while still enforcing immutability after object construction.

Benefits of Init Over Private Set

Previously, developers used a private set accessor to limit property modification outside the class.

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Private privateFirstName As String
	Public Property FirstName() As String
		Get
			Return privateFirstName
		End Get
		Private Set(ByVal value As String)
			privateFirstName = value
		End Set
	End Property
	Private privateLastName As String
	Public Property LastName() As String
		Get
			Return privateLastName
		End Get
		Private Set(ByVal value As String)
			privateLastName = value
		End Set
	End Property
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Although this approach works, it requires constructor boilerplate code to initialize properties. Also, it allows the class itself to modify the properties later, which isn't always ideal for immutable objects. The init keyword removes this issue, as it only allows Initialization at object creation time and blocks any modification afterward.

Handling Initialization with read-only Fields and init Accessors

The init keyword can initialize fields or properties during object creation while they remain immutable afterward. While read-only fields provide immutability, the init accessor offers a similar capability for properties. Here's how you can handle immutability in two ways: using read-only fields and init properties.

Using read-only Fields with a Constructor

In this example, we use read-only fields for firstName and lastName, which are set during object construction. These fields can only be assigned once in the constructor and cannot be modified afterward:

public class Person
{
    private readonly string firstName;
    private readonly string lastName;
    public string FirstName => firstName;
    public string LastName => lastName;
    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

public class Person
{
    private readonly string firstName;
    private readonly string lastName;
    public string FirstName => firstName;
    public string LastName => lastName;
    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Public Class Person
'INSTANT VB NOTE: The field firstName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly firstName_Conflict As String
'INSTANT VB NOTE: The field lastName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly lastName_Conflict As String
	Public ReadOnly Property FirstName() As String
		Get
			Return firstName_Conflict
		End Get
	End Property
	Public ReadOnly Property LastName() As String
		Get
			Return lastName_Conflict
		End Get
	End Property
	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.firstName_Conflict = firstName
		Me.lastName_Conflict = lastName
	End Sub
End Class

Using init Accessors for Initialization

Alternatively, we can use the init accessor to create read-only properties that can be initialized during object creation but can't be changed afterward. This eliminates the need for read-only fields and provides a more modern syntax:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Introduction to IronPDF

IronPDF is a powerful PDF generation and manipulation library designed for C# developers. It simplifies working with PDFs by converting HTML, CSS, images, and other content into PDF documents. With features like pixel-perfect rendering, cross-platform support, and easy integration into .NET projects, IronPDF is ideal for developers needing to create high-quality PDFs quickly. You can use it with .NET Core, Framework, and Standard, and it supports a wide range of platforms, including Windows, Linux, and macOS.

Case: Using IronPDF with C# Init Keyword

To create immutable objects in a C# project while generating PDFs, you can combine the init keyword with IronPDF. The init keyword ensures the object's integrity after it's initialized, while IronPDF processes the data and generates PDFs based on that immutable model.

Make sure IronPDF is correctly referenced in your project. You can install it via NuGet:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Here is the code example:

using IronPdf;
public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };
        PDFGenerator.CreatePersonPDF(person);
    }
}

using IronPdf;
public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}
public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };
        PDFGenerator.CreatePersonPDF(person);
    }
}

Imports IronPdf
Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class
Public Class PDFGenerator
	Public Shared Sub CreatePersonPDF(ByVal person As Person)
		Dim htmlContent = $"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs($"Person_{person.Id}.pdf")
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Id = 1,
			.FirstName = "Iron",
			.LastName = "Dev"
		}
		PDFGenerator.CreatePersonPDF(person)
	End Sub
End Class

Conclusion

In summary, the C# init keyword allows you to create immutable objects while offering flexibility during object initialization. It's a cleaner and safer alternative to private set accessors, reducing the need for constructor boilerplate code. Combining the init keyword with read-only fields, structs, and validation logic helps you to build robust and secure data structures that preserve immutability without sacrificing readability or flexibility. IronPDF offers a free trial, and licenses start from $749. This gives you access to its full features, including editing, compressing, and securing PDFs.