Palavra-chave Init em C# (Como funciona para desenvolvedores)

Exemplo básico da palavra-chave init

Vamos começar com um exemplo básico:

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

var person = new Person
{
    FirstName = "Iron",
    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",
    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",
	.LastName = "Dev"
}

' person.FirstName = "Jane";  // This will give a compile-time error.

Neste exemplo, FirstName e LastName são marcadas como propriedades somente de inicialização. Isso significa que eles só podem ser atribuídos durante a inicialização do objeto. Após a criação do objeto, qualquer tentativa de alterar seus valores causará um erro de compilação.

Por que usar a palavra-chave init?

O principal motivo para usar a palavra-chave init é tornar as propriedades do objeto imutáveis ​​após a inicialização. Tradicionalmente, você poderia marcar propriedades como somente leitura para obter imutabilidade. No entanto, muitas vezes você precisará de um construtor que aceite todos os valores necessários para definir os campos, o que pode levar a um código repetitivo no construtor. Com o init, você pode atingir o mesmo objetivo usando inicializadores de objetos sem escrever construtores longos.

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"
}

Inicialização de objetos com propriedades somente de inicialização

O uso do init funciona perfeitamente com inicializadores de objetos. Em vez de depender de construtores para definir valores, você pode definir as propriedades necessárias diretamente ao criar um objeto.

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

Isso cria um objeto simples e imutável do tipo Point. Observe que os valores para X e Y são definidos na inicialização e não podem ser modificados posteriormente.

Misturando inicialização com construtores

Embora o principal caso de uso para init seja a inicialização de objetos por meio de inicializadores de objetos, você ainda pode usar um construtor, se necessário. Isso é particularmente útil ao impor valores de propriedade específicos durante a criação de objetos.

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

Você pode usar tanto construtores quanto propriedades de inicialização em conjunto. Essa abordagem oferece mais flexibilidade, ao mesmo tempo que garante a imutabilidade após a construção do objeto.

Vantagens do conjunto inicial em relação ao conjunto privado

Anteriormente, os desenvolvedores usavam um acessador de conjunto privado para limitar a modificação de propriedades fora da classe.

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

Embora essa abordagem funcione, ela exige código repetitivo no construtor para inicializar as propriedades. Além disso, permite que a própria classe modifique as propriedades posteriormente, o que nem sempre é ideal para objetos imutáveis. A palavra-chave init resolve esse problema, pois permite a inicialização apenas no momento da criação do objeto e bloqueia qualquer modificação posterior.

Lidando com a inicialização de campos somente leitura e acessadores de inicialização.

A palavra-chave init pode inicializar campos ou propriedades durante a criação de um objeto, mantendo-os imutáveis ​​posteriormente. Embora os campos somente leitura ofereçam imutabilidade, o acessador init oferece uma capacidade semelhante para propriedades. Eis como você pode lidar com a imutabilidade de duas maneiras: usando campos somente leitura e propriedades de inicialização.

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

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

Introdução ao IronPDF

IronPDF é uma poderosa biblioteca para geração e manipulação de PDFs, projetada para desenvolvedores C#. Simplifica o trabalho com PDFs, convertendo HTML , CSS, imagens e outros conteúdos em documentos PDF. Com recursos como renderização perfeita em pixels, suporte multiplataforma e fácil integração em projetos .NET , o IronPDF é ideal para desenvolvedores que precisam criar PDFs de alta qualidade rapidamente. Você pode usá-lo com .NET Core, Framework e Standard, e ele oferece suporte a uma ampla gama de plataformas, incluindo Windows, Linux e macOS.

Install-Package IronPdf

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

Conclusão

Em resumo, a palavra-chave init do C# permite criar objetos imutáveis, oferecendo flexibilidade durante a inicialização do objeto. É uma alternativa mais limpa e segura aos acessadores de conjuntos privados, reduzindo a necessidade de código repetitivo no construtor. A combinação da palavra-chave init com campos somente leitura, structs e lógica de validação ajuda a construir estruturas de dados robustas e seguras que preservam a imutabilidade sem sacrificar a legibilidade ou a flexibilidade. O IronPDF oferece um teste gratuito e as licenças começam a partir de $799 . Isso lhe dá acesso a todos os seus recursos, incluindo edição, compressão e proteção de PDFs.