AIDE .NET

C# Init Keyword (Comment ça marche pour les développeurs)

Jordi Bardia

octobre 24, 2024

Lesmot-clé init en C# 9.0 a introduit une nouvelle façon de définir les propriétés des classes pour créer des objets immuables. Dans les versions antérieures de C#, les propriétés étaient généralement utilisées pour obtenir et définir des accesseurs permettant de lire et d'écrire dans les champs des objets. Cependant, avec init, vous pouvez rendre les propriétés accessibles en écriture uniquement lors de l'initialisation de l'objet et les laisser en lecture seule par la suite.

Ce tutoriel explorera l'utilisation du mot-clé init de C# avec des exemples pratiques et des scénarios avec l'outil de traductionBibliothèque IronPDF. Vous découvrirez également les différences essentielles entre les fixateurs de propriétés traditionnels(ensemble) et les nouveaux paramètres init-only.

Exemple de base du mot-clé Init

Commençons par un exemple simple :

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.

Mot-clé C# Init (Comment ça marche pour les développeurs) : Figure 1 - L'IDE envoie une erreur parce que les propriétés sont marquées comme init-only

Dans cet exemple, FirstName et LastName sont marqués comme propriétés init-only. Cela signifie qu'ils ne peuvent être assignés que lors de l'initialisation d'un objet. Une fois l'objet créé, toute tentative de modification des valeurs entraînera une erreur de compilation.

Pourquoi utiliser le mot-clé Init ?

La principale raison d'utiliser le mot-clé init est de rendre les propriétés des objets immuables après l'initialisation. Traditionnellement, vous pouviez marquer les propriétés en lecture seule pour obtenir l'immutabilité. Cependant, vous aurez souvent besoin d'un constructeur qui accepte toutes les valeurs nécessaires pour définir les champs, ce qui peut conduire à un code de construction de type "boilerplate". Avec init, vous pouvez atteindre le même objectif en utilisant des initialisateurs d'objets sans écrire de longs constructeurs.

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

Initialisation des objets avec les propriétés Init-Only

L'utilisation de init fonctionne de manière transparente avec les initialisateurs d'objets. Au lieu de s'appuyer sur les constructeurs pour définir les valeurs, vous pouvez définir les propriétés dont vous avez besoin directement lors de la création d'un objet.

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

Cela crée un objet simple et immuable de type Point. Notez que les valeurs de X et Y sont définies lors de l'initialisation et ne peuvent pas être modifiées ultérieurement.

Mélange d'init et de constructeurs

Bien que le principal cas d'utilisation de init soit l'initialisation d'objets via des initialisateurs d'objets, vous pouvez toujours utiliser un constructeur si nécessaire. Ces outils sont particulièrement utiles lorsqu'il s'agit d'imposer des valeurs de propriétés spécifiques lors de la création d'objets.

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

Vous pouvez utiliser les constructeurs et les propriétés init ensemble. Cette approche offre une plus grande flexibilité tout en garantissant l'immuabilité après la construction de l'objet.

Avantages d'Init par rapport à Private Set

Auparavant, les développeurs utilisaient un accesseur set privé pour limiter la modification des propriétés en dehors de la 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

Bien que cette approche fonctionne, elle nécessite un code de construction pour initialiser les propriétés. En outre, elle permet à la classe elle-même de modifier les propriétés ultérieurement, ce qui n'est pas toujours idéal pour les objets immuables. Le mot-clé init élimine ce problème, car il n'autorise l'initialisation qu'au moment de la création de l'objet et bloque toute modification ultérieure.

Gestion de l'initialisation avec des champs en lecture seule et des accesseurs init

Le mot-clé init permet d'initialiser des champs ou des propriétés lors de la création d'un objet tout en les laissant immuables par la suite. Alors que les champs en lecture seule permettent l'immutabilité, l'accesseur init offre une capacité similaire pour les propriétés. Voici comment vous pouvez gérer l'immutabilité de deux manières : en utilisant des champs en lecture seule et des propriétés init.

Utilisation de champs en lecture seule avec un constructeur

Dans cet exemple, nous utilisons des champs en lecture seule pour firstName et lastName, qui sont définis lors de la construction de l'objet. Ces champs ne peuvent être attribués qu'une seule fois dans le constructeur et ne peuvent être modifiés par la suite :

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

Utilisation des accesseurs init pour l'initialisation

Nous pouvons également utiliser l'accesseur init pour créer des propriétés en lecture seule qui peuvent être initialisées lors de la création de l'objet, mais qui ne peuvent plus être modifiées par la suite. La traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement, ce qui élimine le besoin de champs en lecture seule et offre une syntaxe plus moderne :

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 à IronPDF

Mot-clé C# Init(Comment ça marche pour les développeurs) : Figure 2 - IronPDF : La bibliothèque PDF C#

IronPDF est une puissante bibliothèque de génération et de manipulation de PDF conçue pour les développeurs C#. Il simplifie le travail avecPDF en convertissant HTMLla traduction d'un document PDF peut être réalisée par l'intermédiaire d'un logiciel de création de contenu, de CSS, d'images et d'autres contenus dans des documents PDF. Avec des fonctionnalités telles qu'un rendu parfait au pixel près, une prise en charge multiplateforme et une intégration facile dans les projets .NET, IronPDF est idéal pour les développeurs qui ont besoin de créer rapidement des PDF de haute qualité. Vous pouvez l'utiliser avec .NET Core, Framework et Standard, et il prend en charge un large éventail de plateformes, notamment Windows, Linux et macOS.

Cas pratique : Utilisation d'IronPDF avec C&num ; Mot-clé Init

Pour créer des objets immuables dans un projet C# tout en générant des PDF, vous pouvez combiner le mot-clé init avec IronPDF. Le mot-clé init garantit l'intégrité de l'objet après son initialisation, tandis qu'IronPDF traite les données et génère des PDF sur la base de ce modèle immuable.

Assurez-vous qu'IronPDF est correctement référencé dans votre projet. Vous pouvez l'installer via NuGet :

Install-Package IronPdf

Install-Package IronPdf

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

Voici l'exemple de code :

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

Mot-clé C# Init (Comment ça marche pour les développeurs) : Figure 3 - Page de licence d'IronPDF

En résumé, le mot-clé init de C# permet de créer des objets immuables tout en offrant une certaine flexibilité lors de l'initialisation des objets. Il s'agit d'une alternative plus propre et plus sûre aux accesseurs d'ensembles privés, qui réduit la nécessité d'un code de construction de type "boilerplate". La combinaison du mot-clé init avec des champs en lecture seule, des structures et une logique de validation vous aide à construire des structures de données robustes et sécurisées qui préservent l'immutabilité sans sacrifier la lisibilité ou la flexibilité. IronPDF offre un service deessai gratuit, et les licences commencent à partir de $749. Cela vous permet d'accéder à l'ensemble de ses fonctionnalités, notamment l'édition, la compression et la sécurisation des PDF.

Jordi Bardia

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Jordi maîtrise parfaitement Python, C# et C++. Lorsqu'il ne met pas à profit ses compétences chez Iron Software, il se consacre à la programmation de jeux. Partageant des responsabilités en matière de tests de produits, de développement de produits et de recherche, Jordi apporte une valeur ajoutée considérable à l'amélioration continue des produits. Cette expérience variée le stimule et l'engage, et il dit que c'est l'un des aspects qu'il préfère dans son travail chez Iron Software. Jordi a grandi à Miami, en Floride, et a étudié l'informatique et les statistiques à l'université de Floride.

< PRÉCÉDENT
FileStream C# (Comment ça marche pour les développeurs)

SUIVANT >
C# Semaphoreslim (Comment ça marche pour les développeurs)