Palabra clave C# Init (Cómo funciona para desarrolladores)

Enpalabra clave init en C# 9.0 introdujo una nueva forma de definir propiedades de clase para crear objetos inmutables. En versiones anteriores de C#, las propiedades se utilizaban normalmente para obtener y establecer accesos para leer y escribir en campos de objetos. Sin embargo, con init, puede hacer que las propiedades sean escribibles sólo durante la inicialización del objeto y que sigan siendo de sólo lectura después.

Este tutorial explorará el uso de la palabra clave init de C# con ejemplos prácticos y escenarios con la herramientaBiblioteca IronPDF. También conocerás las diferencias fundamentales entre los definidores de propiedades tradicionales(configure) y los nuevos configuradores init-only.

Ejemplo básico de la palabra clave Init

Empecemos con un ejemplo básico:

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.

En este ejemplo, FirstName y LastName están marcados como propiedad init-only. Esto significa que sólo pueden asignarse durante un inicializador de objetos. Una vez creado el objeto, si se intenta cambiar los valores se producirá un error de compilación.

¿Por qué utilizar la palabra clave Init?

La razón principal para utilizar la palabra clave init es hacer que las propiedades de los objetos sean inmutables después de la inicialización. Tradicionalmente, se podían marcar las propiedades como de sólo lectura para conseguir la inmutabilidad. Sin embargo, a menudo se necesita un constructor que acepte todos los valores necesarios para establecer los campos, lo que puede dar lugar a código repetitivo en el constructor. Con init, puede lograr el mismo objetivo utilizando inicializadores de objetos sin escribir largos constructores.

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

Inicialización de objetos con propiedades Init-Only

El uso de init funciona a la perfección con inicializadores de objetos. En lugar de depender de constructores para establecer valores, puede definir las propiedades que necesite directamente mientras crea un 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

Esto crea un objeto simple e inmutable de tipo Point. Observe que los valores de X e Y se establecen en la inicialización y no pueden modificarse posteriormente.

Mezclar init con constructores

Aunque el caso de uso principal de init es la inicialización de objetos mediante inicializadores de objetos, también se puede utilizar un constructor si es necesario. Esto resulta especialmente útil a la hora de imponer valores de propiedad específicos durante la creación 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

Puede utilizar tanto los constructores como las propiedades init juntos. Este enfoque es más flexible y mantiene la inmutabilidad tras la construcción del objeto.

Ventajas de Init sobre Private Set

Anteriormente, los desarrolladores utilizaban un accesor de conjunto privado para limitar la modificación de propiedades fuera de la clase.

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

Aunque este enfoque funciona, requiere código constructor para inicializar las propiedades. Además, permite que la propia clase modifique las propiedades posteriormente, lo que no siempre es ideal para objetos inmutables. La palabra clave init elimina este problema, ya que sólo permite la inicialización en el momento de la creación del objeto y bloquea cualquier modificación posterior.

Manejo de la inicialización con campos de sólo lectura y accesores init

La palabra clave init puede inicializar campos o propiedades durante la creación de un objeto, mientras que después permanecen inmutables. Mientras que los campos de sólo lectura proporcionan inmutabilidad, el accesor init ofrece una capacidad similar para las propiedades. A continuación se explica cómo se puede gestionar la inmutabilidad de dos formas: utilizando campos de sólo lectura y propiedades init.

Uso de campos de sólo lectura con un constructor

En este ejemplo, utilizamos campos de sólo lectura para firstName y lastName, que se establecen durante la construcción del objeto. Estos campos sólo pueden asignarse una vez en el constructor y no pueden modificarse después:

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

Uso de accesores init para inicialización

Como alternativa, podemos utilizar el accesorio init para crear propiedades de sólo lectura que se pueden inicializar durante la creación del objeto, pero que no se pueden cambiar después. Esto elimina la necesidad de campos de solo lectura y proporciona una sintaxis más moderna:

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

Introducción a IronPDF

IronPDF es una potente biblioteca de generación y manipulación de PDF diseñada para desarrolladores de C#. Simplifica el trabajo conPDF mediante la conversión de HTMLtraducción de textos, CSS, imágenes y otros contenidos a documentos PDF. IronPDF es ideal para los desarrolladores que necesitan crear rápidamente archivos PDF de alta calidad, ya que cuenta con funciones como la renderización perfecta de píxeles, la compatibilidad multiplataforma y la fácil integración en proyectos .NET. Se puede utilizar con .NET Core, Framework y Standard, y es compatible con una amplia gama de plataformas, como Windows, Linux y macOS.

Caso práctico: Uso de IronPDF con C# palabra clave Init

Para crear objetos inmutables en un proyecto de C# mientras se generan archivos PDF, puede combinar la palabra clave init con IronPDF. La palabra clave init garantiza la integridad del objeto una vez inicializado, mientras que IronPDF procesa los datos y genera PDF basados en ese modelo inmutable.

Asegúrese de que IronPDF está correctamente referenciado en su proyecto. Puede instalarlo a través de NuGet:

Install-Package IronPdf

Install-Package IronPdf

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

He aquí el ejemplo de código:

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

Conclusión

En resumen, la palabra clave init de C# permite crear objetos inmutables al tiempo que ofrece flexibilidad durante la inicialización de objetos. Se trata de una alternativa más limpia y segura a los accesores de conjuntos privados, que reduce la necesidad de código repetitivo en los constructores. La combinación de la palabra clave init con campos de sólo lectura, structs y lógica de validación ayuda a construir estructuras de datos robustas y seguras que preservan la inmutabilidad sin sacrificar la legibilidad o la flexibilidad. IronPDF ofrece un**Prueba gratuitay licencias a partir de 749 dólares. Esto le da acceso a todas sus funciones, incluidas las de edición, compresión y protección de PDF.