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

Constructeur principal C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Dans le paysage orienté objet de la programmation C#, l'introduction des constructeurs primaires apporte un nouveau niveau d'élégance et de simplicité au langage. Les constructeurs primaires, aux côtés de fonctionnalités telles que les intercepteurs et les expressions de collection, ont émergé dans C# 12 comme une fonctionnalité puissante, offrant une syntaxe plus concise pour déclarer des constructeurs avec des paramètres. Vous pouvez explorer en profondeur les constructeurs primaires sur le guide Microsoft C#.

Dans cet article, nous apprendrons comment utiliser efficacement les constructeurs primaires de C# 12, en explorant également leur fonctionnalité, leurs cas d'utilisation, et comment ils transforment la façon dont les développeurs abordent l'initialisation des classes.

Comprendre les bases : Les constructeurs en C#

Les constructeurs jouent un rôle central dans la programmation orientée objet, servant de modèle pour initialiser des objets. Traditionnellement, les développeurs C# ont utilisé le constructeur par défaut ou des constructeurs avec paramètres pour configurer l'état initial de leurs classes. Cependant, l'introduction des constructeurs primaires ajoute une approche plus rationalisée à cet aspect essentiel du développement C#.

L'essence des constructeurs primaires

Un constructeur primaire en C# est un moyen concis de déclarer et d'initialiser les propriétés directement dans la déclaration de la classe. Il simplifie le processus de définition et d'attribution de valeurs aux propriétés, offrant une syntaxe plus déclarative et lisible.

Avantages des constructeurs primaires

  1. Concision : Les constructeurs primaires offrent une syntaxe succincte, réduisant le code boilerplate et améliorant la lisibilité.
  2. Portée : Contrairement aux constructeurs traditionnels, les paramètres dans les constructeurs primaires sont dans la portée de l'ensemble de la classe ou de la structure, offrant de la flexibilité dans leur utilisation.
  3. Valeurs par défaut : Les valeurs de paramètres par défaut simplifient la création d'objets, la rendant plus pratique pour les développeurs.

Déclarer un constructeur primaire

La syntaxe d'un constructeur primaire implique de déclarer les propriétés directement dans l'en-tête de la classe. Considérons un exemple de classe Person de base :

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}
public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}
Public Class Person(String name, Integer age)
	Public ReadOnly Property Name() As String = name
	Public ReadOnly Property Age() As Integer = age
	Public Overrides Function ToString() As String
		Return $"Name: {Name}, Age: {Age}"
	End Function
End Class
$vbLabelText   $csharpLabel

Dans l'exemple de code ci-dessus, la classe Person a un constructeur primaire qui initialise les propriétés membres d'instance Name et Age. Les paramètres du constructeur sont déclarés avec le nom de la classe ou de la structure, et lors de la définition des propriétés publiques, les valeurs des paramètres leur sont attribuées.

Exemple 1 : Point immuable dans l'espace 2D

public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}
public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}
'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point(double x, double y)
Public Structure Point(Double x, Double y)
	Public ReadOnly Property X() As Double = x
	Public ReadOnly Property Y() As Double = y
	Public ReadOnly Property Magnitude() As Double
		Get
			Return Math.Sqrt(X * X + Y * Y)
		End Get
	End Property
End Structure
$vbLabelText   $csharpLabel

Dans cet exemple, le constructeur primaire de la structure Point initialise les propriétés X et Y, illustrant à quel point la syntaxe peut être concise et expressive.

Exemple 2 : Logger configurable avec paramètres par défaut

public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;

    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}
public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;

    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}
'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
Public Class Logger(String filePath = "log.txt", LogLevel level = LogLevel.Info)
	Private ReadOnly _filePath As String = filePath
	Private ReadOnly _level As LogLevel = level

	Public Sub Log(ByVal message As String)
		' Actual logging implementation using _filePath and _level
	End Sub
End Class
$vbLabelText   $csharpLabel

Ici, le constructeur primaire de la classe Logger fournit des valeurs par défaut pour filePath et level, la rendant flexible et facile à utiliser tout en maintenant la configurabilité.

Exemple 3 : Injection de dépendance

public interface IService
{
    Distance GetDistance();
}

public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}
public interface IService
{
    Distance GetDistance();
}

public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}
Public Interface IService
	Function GetDistance() As Distance
End Interface

Public Class ExampleController(IService service)
	Inherits ControllerBase

	Public Function [Get]() As ActionResult(Of Distance)
		Return service.GetDistance()
	End Function
End Class
$vbLabelText   $csharpLabel

Les constructeurs primaires conviennent aux scénarios d'injection de dépendance. Dans cet exemple, une classe de contrôleur indique ses dépendances, améliorant la maintenabilité et facilitant les tests unitaires.

Exemple 4 : Construire une hiérarchie de formes géométriques

public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}

public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}

public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}
public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}

public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}

public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}
Public MustInherit Class Shape(Double width, Double height)
	Public ReadOnly Property Width() As Double = width
	Public ReadOnly Property Height() As Double = height
	Public MustOverride Function CalculateArea() As Double
End Class

Public Class Rectangle(Double width, Double height)
	Inherits Shape(width, height)

	Public Overrides Function CalculateArea() As Double
		Return Width * Height
	End Function
End Class

Public Class Circle
	Inherits Shape

	Public Sub New(ByVal radius As Double)
		MyBase.New(radius * 2, radius * 2)
	End Sub
	Public Overrides Function CalculateArea() As Double
		Return Math.PI * Math.Pow(Width / 2, 2)
	End Function
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, le constructeur primaire de la classe Shape forme la base d'une hiérarchie de formes géométriques. Les sous-classes comme Rectangle et Circle tirent parti du constructeur primaire pour une initialisation cohérente. La classe Rectangle elle-même déclare le constructeur primaire et passe les paramètres du constructeur primaire capturés à la classe Shape en tant que paramètres primaires. La classe Circle démontre de la flexibilité en définissant son constructeur dans la classe entière puis en passant ses paramètres comme valeurs par défaut pour le constructeur de Shape en utilisant le mot-clé base.

Présentation d'IronPDF

IronPDF est une bibliothèque C# polyvalente qui permet aux développeurs de créer, manipuler et convertir des fichiers PDF sans effort. Que vous génériez des factures, des rapports ou tout autre document, IronPDF vous permet de convertir sans problème le contenu HTML en PDFs soignés et professionnels directement dans votre application C#.

IronPDF est un outil pratique pour les développeurs qui leur permet de transformer des pages web, des URL, et HTML en PDF. Le meilleur aspect est que les PDFs ressemblent exactement aux pages web originales, avec tout le formatage et le style préservés. Il est parfait pour créer des PDFs à partir de contenu web tel que des rapports et des factures.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Constructeur principal C# (comment ça fonctionne pour le développeur) : Figure 1 - page Web IronPDF

Installer IronPDF : Un démarrage rapide

Pour intégrer IronPDF dans votre projet C#, commencez par installer le package NuGet IronPDF. Exécutez la commande suivante dans votre Console du Gestionnaire de Packages :

Install-Package IronPdf

Sinon, trouvez "IronPDF" dans le Gestionnaire de Packages NuGet et procédez à l'installation à partir de là.

Constructeur principal C# (comment ça fonctionne pour le développeur) : Figure 2 - Recherche du package IronPDF dans le navigateur du gestionnaire de packages NuGet

Générer des PDFs avec IronPDF

Créer un PDF en utilisant IronPDF est un processus rationalisé. Considérez l'exemple suivant :

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");
var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");
Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
' Create a new PDF document
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")
$vbLabelText   $csharpLabel

Dans cet exemple, IronPDF est utilisé pour rendre le contenu HTML dans un document PDF, qui est ensuite enregistré à l'emplacement spécifié. For more details on creating and manipulating PDFs in C#, please visit this complete tutorial link, and to explore more please visit this documentation page.

Constructeurs primaires C# : une révolution pour l'initialisation des classes

Les constructeurs primaires C# offrent une approche déclarative et rationalisée pour initialiser les propriétés des classes directement dans la déclaration de la classe. Voyons si cette fonctionnalité élégante peut être intégrée en douceur avec IronPDF.

Intégration des constructeurs primaires C# avec IronPDF

Bien que les constructeurs primaires C# soient avant tout une fonctionnalité du langage axée sur l'initialisation de classes, leur intégration directe avec IronPDF peut ne pas être un cas d'utilisation courant. La fonctionnalité principale d'IronPDF réside dans la génération et la manipulation de documents PDF, et les spécificités de l'initialisation de classes peuvent ne pas s'aligner directement avec ce flux de travail.

Cependant, les développeurs peuvent tirer parti des constructeurs primaires C# lors de la définition de classes ou structures personnalisées liées aux configurations ou modèles de données IronPDF. Par exemple, si votre application nécessite une structure de classe spécifique pour gérer les paramètres ou les configurations liées au PDF, les constructeurs primaires C# peuvent être un outil précieux pour initialiser ces classes de manière concise.

public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}

// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions
{
    PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
    MarginTop = 20,
    MarginBottom = 20,
    MarginLeft = 10,
    MarginRight = 10,
    Title = pdfSettings.Title
};
// Apply settings from PdfGenerationSettings
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");
public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}

// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions
{
    PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
    MarginTop = 20,
    MarginBottom = 20,
    MarginLeft = 10,
    MarginRight = 10,
    Title = pdfSettings.Title
};
// Apply settings from PdfGenerationSettings
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");
Public Class PdfGenerationSettings(String title, Boolean includeHeader, Boolean includeFooter)
	Public ReadOnly Property Title() As String = title
	Public ReadOnly Property IncludeHeader() As Boolean = includeHeader
	Public ReadOnly Property IncludeFooter() As Boolean = includeFooter
	' Additional properties...
End Class

' Usage with IronPDF
Private pdfSettings = New PdfGenerationSettings("My PDF Title", True, False)
Private renderOptions = New ChromePdfRenderOptions With {
	.PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
	.MarginTop = 20,
	.MarginBottom = 20,
	.MarginLeft = 10,
	.MarginRight = 10,
	.Title = pdfSettings.Title
}
' Apply settings from PdfGenerationSettings
If pdfSettings.IncludeHeader Then
	renderOptions.TextHeader = New TextHeaderFooter With {
		.CenterText = "Page {page} of {total-pages}",
		.DrawDividerLine = True
	}
End If
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderingOptions = renderOptions
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf")
$vbLabelText   $csharpLabel

Dans cet exemple, la classe PdfGenerationSettings utilise un constructeur primaire C# pour initialiser les propriétés relatives aux paramètres de génération de PDF, qui peuvent ensuite être utilisées pour déterminer quelles options de rendu ajouter et lesquelles ignorer. La sortie contient un texte en-tête et un titre tel qu'il a été défini à l'aide du paramètre du constructeur primaire.

Constructeur principal C# (comment ça fonctionne pour le développeur) : Figure 3 - PDF de sortie de l'exemple de code ci-dessus

Conclusion

En conclusion, les constructeurs primaires en C# présentent une approche raffinée et expressive de l'initialisation des classes. Leur syntaxe déclarative renforce la lisibilité du code, promeut l'immutabilité et simplifie le processus de création d'objets avec des valeurs par défaut. Que vous définissiez des propriétés, renforciez l'immutabilité ou embrassiez des valeurs par défaut, les constructeurs primaires permettent aux développeurs de maîtriser l'art de l'initialisation des classes dans le monde dynamique de la programmation C#.

Bien que l'intégration directe des constructeurs primaires C# avec IronPDF ne soit peut-être pas l'objectif principal, ces deux éléments peuvent fonctionner ensemble harmonieusement. Les constructeurs primaires C# améliorent la clarté et la simplicité de l'initialisation des classes, les rendant précieuses pour définir des structures ou configurations liées aux flux de travail IronPDF.

Exploitez la puissance d'IronPDF pour une génération robuste de PDFs, et utilisez les constructeurs primaires C# là où l'élégance de l'initialisation de classe est primordiale. Ce duo dynamique vous permet de naviguer dans les complexités de la génération de documents avec créativité et efficience dans le monde vibrant de la programmation C#.

IronPDF offers a free trial and its lite license starts from $799.

Questions Fréquemment Posées

Comment les constructeurs principaux rendent-ils le code C# plus concis?

Les constructeurs principaux permettent de déclarer et d'initialiser des propriétés directement dans la déclaration de classe, réduisant la quantité de code standard et améliorant la lisibilité.

Quelles sont les nouvelles fonctionnalités introduites dans C# 12?

C# 12 introduit des constructeurs principaux, des intercepteurs et des expressions de collection, qui offrent ensemble des options de syntaxe plus concises et puissantes pour les développeurs.

Les constructeurs principaux peuvent-ils être utilisés avec des structures de données immuables?

Oui, les constructeurs principaux conviennent bien aux structures de données immuables car ils permettent l'initialisation de propriétés en lecture seule directement dans le constructeur.

Comment puis-je convertir du contenu HTML en PDF en utilisant C# ?

Vous pouvez utiliser la classe ChromePdfRenderer d'IronPDF pour convertir le contenu HTML en PDF, en veillant à ce que le formatage et le style soient conservés dans le document de sortie.

Quels sont les avantages d'utiliser IronPDF pour la génération de PDF?

IronPDF fournit une plateforme robuste pour créer et manipuler des fichiers PDF en C#, prenant en charge des fonctionnalités comme la conversion HTML en PDF, la fusion de PDF et la conservation détaillée du style.

Comment les constructeurs principaux améliorent-ils l'injection de dépendances?

Les constructeurs principaux améliorent l'injection de dépendances en indiquant clairement les dépendances de la classe dans les paramètres du constructeur, ce qui simplifie la configuration et la maintenance du graphe de dépendances.

Comment les constructeurs principaux peuvent-ils être intégrés à la génération de documents PDF?

Les constructeurs principaux peuvent être utilisés pour initialiser des classes de configuration ou des structures associées aux paramètres PDF lors de l'utilisation d'une bibliothèque comme IronPDF, simplifiant ainsi le processus de configuration.

Quels sont quelques exemples pratiques de constructeurs principaux en action?

Des exemples pratiques incluent l'initialisation de hiérarchies de formes géométriques et de scénarios d'injection de dépendances où la clarté et la concision sont essentielles.

Comment les développeurs peuvent-ils commencer à utiliser IronPDF dans leurs projets?

Les développeurs peuvent installer le package NuGet IronPDF via la console du gestionnaire de packages ou le gestionnaire de packages NuGet et se référer à la documentation complète pour les détails de l'implémentation.

Quel rôle joue IronPDF dans les flux de travail de génération de documents?

IronPDF améliore les flux de travail de génération de documents en permettant aux développeurs de créer, convertir et manipuler facilement des PDF en C#, prenant en charge une intégration transparente avec d'autres fonctionnalités C#.

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