Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Init Keyword
.NET AIDE

Mot-clé C# Init (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Le mot-clé init de C# 9.0 a introduit une nouvelle façon de définir les propriétés de classe pour créer des objets immuables. Dans les versions antérieures de C#, les propriétés étaient généralement utilisées avec des accesseurs get et set pour lire et écrire dans les champs d'un objet. Cependant, avec init, vous pouvez rendre les propriétés modifiables uniquement pendant l'initialisation de l'objet, les rendant ensuite en lecture seule.

Ce tutoriel explorera l'utilisation du mot-clé init de C# avec des exemples pratiques et des scénarios utilisant la bibliothèque IronPDF. Vous apprendrez également les différences essentielles entre les accesseurs de propriété traditionnels (set) et les nouveaux accesseurs init-only.

Exemple de base du mot-clé Init

Commençons par un exemple de base :

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.
$vbLabelText   $csharpLabel

Mot-clé Init C# (Comment ça fonctionne pour les développeurs) : Figure 1 - IDE générant une erreur due aux propriétés marquées comme init-only

Dans cet exemple, FirstName et LastName sont marqués comme des propriétés init-only. Cela signifie qu'ils ne peuvent être assignés que pendant l'initialisation de l'objet. Après la création de l'objet, tenter de changer les valeurs entraînera une erreur à la compilation.

Pourquoi utiliser le mot-clé Init ?

La raison principale de l'utilisation du mot-clé init est de rendre les propriétés d'un objet immuables après l'initialisation. Traditionnellement, vous pouviez marquer les propriétés comme en lecture seule pour atteindre l'immutabilité. Cependant, vous auriez souvent besoin d'un constructeur qui accepte toutes les valeurs nécessaires pour définir les champs, ce qui peut entraîner du code redondant pour le constructeur. Avec init, vous pouvez atteindre le même objectif en utilisant des initialiseurs d'objet 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"
}
$vbLabelText   $csharpLabel

Initialisation d'objet avec des propriétés Init-Only

L'utilisation d'init fonctionne parfaitement avec les initialiseurs d'objet. Au lieu de s'appuyer sur des constructeurs pour définir des 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
$vbLabelText   $csharpLabel

Cela crée un objet simple, immuable du 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élanger init avec des constructeurs

Bien que le cas d'utilisation principal pour init soit l'initialisation d'objet via des initialiseurs d'objet, vous pouvez toujours utiliser un constructeur si nécessaire. C'est particulièrement utile lorsque vous appliquez des valeurs de propriété spécifiques lors de la création d'un objet.

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
$vbLabelText   $csharpLabel

Vous pouvez utiliser à la fois des constructeurs et des propriétés init conjointement. Cette approche offre plus de flexibilité tout en appliquant l'immutabilité après la construction de l'objet.

Avantages d'Init sur Private Set

Auparavant, les développeurs utilisaient un accesseur private set 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
$vbLabelText   $csharpLabel

Bien que cette approche fonctionne, elle nécessite du code redondant pour le constructeur pour initialiser les propriétés. De plus, elle permet à la classe elle-même de modifier les propriétés plus tard, ce qui n'est pas toujours idéal pour les objets immuables. Le mot-clé init supprime ce problème, car il permet uniquement l'initialisation lors de la création de l'objet et bloque toute modification par la suite.

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

Le mot-clé init peut initialiser des champs ou des propriétés lors de la création de l'objet tout en restant immuables par la suite. Bien que les champs en lecture seule offrent 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.

Utiliser des 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 assignés qu'une fois dans le constructeur et ne peuvent pas ê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
$vbLabelText   $csharpLabel

Utiliser des accesseurs Init pour l'initialisation

Alternativement, nous pouvons 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 ne peuvent pas être modifiées par la suite. Cela élimine le besoin de champs en lecture seule et fournit 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
$vbLabelText   $csharpLabel

Introduction à IronPDF

Mot-clé Init C# (Comment ça fonctionne 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#. Elle simplifie le travail avec les PDFs en convertissant HTML, CSS, images, et d'autres contenus en documents PDF. Avec des fonctionnalités telles que le rendu pixel-parfait, le support multiplateforme, et une intégration facile dans les projets .NET, IronPDF est idéal pour les développeurs ayant besoin de créer rapidement des PDFs de haute qualité. Vous pouvez l'utiliser avec .NET Core, Framework, et Standard, et il prend en charge une large gamme de plateformes, y compris Windows, Linux, et macOS.

Cas : Utiliser IronPDF avec le mot-clé Init de C

Pour créer des objets immuables dans un projet C# tout en générant des PDFs, vous pouvez combiner le mot-clé init avec IronPDF. Le mot-clé init assure l'intégrité de l'objet après son initialisation, tandis qu'IronPDF traite les données et génère des PDFs basés sur 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

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
$vbLabelText   $csharpLabel

Conclusion

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

En résumé, le mot-clé init de C# vous permet de créer des objets immuables tout en offrant de la flexibilité lors de l'initialisation de l'objet. C'est une alternative plus propre et plus sûre aux accesseurs private set, réduisant le besoin de code redondant pour le constructeur. Combiner le 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ûres qui préservent l'immutabilité sans sacrifier la lisibilité ou la flexibilité. IronPDF offre une version d'essai gratuite, et les licences commencent à partir de $799. Cela vous donne accès à toutes ses fonctionnalités, y compris l'édition, la compression et la sécurisation de PDFs.

Questions Fréquemment Posées

Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf.

Quel est le but du mot-clé init en C# ?

Le mot-clé init vous permet de définir des propriétés qui ne peuvent être définies que lors de l'initialisation de l'objet, assurant ainsi l'immuabilité par la suite. Cette fonctionnalité est particulièrement utile pour créer des objets qui ne devraient pas changer une fois créés.

Comment le mot-clé init améliore-t-il l'immuabilité des objets en C# ?

Le mot-clé init permet de définir les propriétés uniquement pendant la phase d'initialisation de l'objet, empêchant tout changement par la suite. Cela garantit que les objets restent immuables une fois créés.

Les propriétés init peuvent-elles être utilisées avec des bibliothèques pour la génération de PDF ?

Oui, les propriétés init peuvent être utilisées avec des bibliothèques comme IronPDF pour générer des PDF à partir d'objets immuables, garantissant que les données utilisées pour le PDF restent cohérentes tout au long du processus.

Quels sont les avantages de l'utilisation du mot-clé init par rapport aux setters traditionnels ?

L'utilisation du mot-clé init par rapport aux setters traditionnels favorise l'immuabilité, réduit le besoin de code de constructeur long et garantit que les propriétés de l'objet ne peuvent pas être modifiées après l'initialisation.

Comment puis-je intégrer la génération de PDF avec des propriétés immuables en C# ?

Vous pouvez créer des objets immuables en utilisant des propriétés init et passer ces objets à IronPDF, qui peut utiliser les données pour générer des documents PDF cohérents et fiables.

Quel rôle joue le mot-clé init dans la création d'applications modernes en C# ?

Le mot-clé init joue un rôle crucial dans la création d'applications modernes en C# en permettant aux développeurs de définir des objets immuables avec une syntaxe concise, améliorant ainsi la sécurité du code et réduisant les bogues.

Comment puis-je installer une bibliothèque pour la génération de PDF dans un projet C# ?

Vous pouvez installer une bibliothèque comme IronPDF dans votre projet C# en utilisant le gestionnaire de packages NuGet avec la commande : Install-Package IronPdf.

Pourquoi l'immuabilité est-elle importante dans le développement d'applications ?

L'immuabilité est importante car elle garantit l'intégrité et la cohérence des données dans votre application, ce qui facilite la maintenance et réduit la probabilité de bogues.

Quels exemples pratiques illustrent l'utilisation du mot-clé init ?

Un exemple pratique est l'utilisation du mot-clé init pour définir une classe avec des propriétés qui ne peuvent être définies que lors de l'initialisation, garantissant ainsi que l'objet créé demeure inchangé. Cela est particulièrement utile dans les scénarios où la cohérence des données est cruciale.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit