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.
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#.
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.
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 basique :
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 ClassDans 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.
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 StructureDans 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.
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 ClassIci, 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é.
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 ClassLes 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.
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 ClassDans 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.
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");
}
}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
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 :
Sinon, trouvez "IronPDF" dans le Gestionnaire de Packages NuGet et procédez à l'installation à partir de là.
Créer un PDF avec 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");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")Dans cet exemple, IronPDF est utilisé pour rendre le contenu HTML dans un document PDF, qui est ensuite enregistré à l'emplacement spécifié. Pour plus de détails sur la création et la manipulation de PDFs en C#, veuillez visiter ce lien de tutoriel complet, et pour explorer plus, veuillez visiter cette page de documentation.
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.
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, 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")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.
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 offre une essai gratuit et sa Licence Lite commence à partir de $999.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
