Constructeur primaire C# (Comment ça marche pour le développeur)

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, sont apparus dans C# 12 comme une fonctionnalité puissante, offrant une syntaxe plus concise pour déclarer des constructeurs avec des paramètres. Vous pouvez explorer les constructeurs primaires en profondeur sur la page Guide C# de Microsoft.

Dans cet article, nous allons apprendre à utiliser efficacement les constructeurs primaires de C# 12, en explorant également leurs fonctionnalités, leurs cas d'utilisation et la manière dont 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 essentiel dans la programmation orientée objet, car ils servent à initialiser les objets. Traditionnellement, les développeurs C# utilisent le constructeur par défaut ou des constructeurs paramétrés pour définir l'état initial de leurs classes. Toutefois, l'introduction des constructeurs primaires permet une approche plus rationnelle de 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 des 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, en offrant une syntaxe plus déclarative et plus lisible.

Avantages des Primary Constructors

1. **Les constructeurs primaires fournissent une syntaxe succincte, réduisant ainsi le code de la plomberie et améliorant la lisibilité.
2. **Contrairement aux constructeurs traditionnels, les paramètres des constructeurs primaires ont une portée sur l'ensemble de la classe ou de la structure, ce qui offre une certaine souplesse d'utilisation.
3. Valeurs par défaut: Les valeurs des paramètres par défaut simplifient la création d'objets, ce qui est plus pratique pour les développeurs.

Déclaration d'un constructeur primaire

La syntaxe d'un constructeur primaire consiste à déclarer les propriétés directement dans l'en-tête de la classe. Prenons l'exemple de la classe Personne :

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 Integer Age {get;} = age public override String ToString()
	If True Then
		Return $"Name: {Name}, Age: {Age}"
	End If
End Class

Dans l'extrait de code ci-dessus, la classe Personne possède un constructeur primaire qui initialise les propriétés Nom et Âge des membres de l'instance. 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

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

Exemple 2 : Enregistreur 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

Ici, le constructeur principal de la classe Logger fournit des valeurs par défaut pour filePath et level, ce qui la rend flexible et facile à utiliser tout en conservant la possibilité de la configurer.

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

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

Exemple 4 : Construction d'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

Dans cet exemple, le constructeur primaire de la classe Shape constitue la base d'une hiérarchie de formes géométriques. Les sous-classes telles que Rectangle et Cercle s'appuient sur le constructeur primaire pour une initialisation cohérente. La classe Rectangle déclare elle-même le constructeur primaire et transmet les paramètres du constructeur primaire capturés aux paramètres primaires de la classe Shape. La classe Cercle fait preuve de flexibilité en définissant son constructeur dans la classe entière et en passant ses paramètres comme valeurs par défaut pour le constructeur Shape à l'aide du 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 produisiez des factures, des rapports ou tout autre document, IronPDF vous permet de convertir en toute transparence du contenu HTML en PDF professionnels et soignés, directement au sein de votre application C#.

Installation d'IronPDF : Un démarrage rapide

Pour intégrer IronPDF à votre projet C#, commencez par installer le package NuGet IronPDF. Exécutez la commande suivante dans la console du gestionnaire de paquets :

Install-Package IronPdf

Vous pouvez également localiser "IronPDF" dans le gestionnaire de paquets NuGet et procéder à l'installation à partir de là.

Générer des PDF avec IronPDF

La création d'un PDF à l'aide d'IronPDF est un processus rationalisé. Prenons 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")

Dans cet exemple, IronPDF est utilisé pour convertir le contenu HTML en un document PDF, qui est ensuite enregistré à l'emplacement spécifié. Pour plus de détails sur la création et la manipulation de fichiers PDF en C#, veuillez consulter ce site complet lien vers le didacticiel, et pour en savoir plus, visitez le site suivant documentation page.

C# ; Constructeurs primaires : Une révolution dans l'initialisation des classes

Les constructeurs primaires C# offrent une approche déclarative et simplifiée de l'initialisation des propriétés de la classe directement dans la déclaration de la classe. Voyons si cette élégante fonctionnalité peut être intégrée de manière transparente à IronPDF.

Intégration de C# ; Primary Constructors avec IronPDF

Alors que les constructeurs primaires de C# sont principalement une caractéristique du langage axée sur l'initialisation des classes, leur intégration directe avec IronPDF n'est peut-être pas 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 des classes peuvent ne pas s'aligner directement sur ce flux de travail.

Cependant, les développeurs peuvent utiliser les constructeurs primaires C# pour définir des classes ou des structures personnalisées liées aux configurations ou aux 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és au format 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();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
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();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
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()
' Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderOptions.MarginTop = 20
renderOptions.MarginBottom = 20
renderOptions.MarginLeft = 10
renderOptions.MarginRight = 10
renderOptions.Title = If(pdfSettings.Title, String.Empty)
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 liées aux paramètres de génération de PDF. Plus tard, cela peut être utilisé pour déterminer les options de rendu à ajouter et celles à ignorer. La sortie contient un texte d'en-tête et un titre tels qu'ils ont été définis à l'aide du paramètre principal du constructeur.

Conclusion

En conclusion, les Primary Constructors en C# présentent une approche raffinée et expressive de l'initialisation des classes. Leur syntaxe déclarative améliore la lisibilité du code, favorise l'immutabilité et simplifie le processus de création d'objets avec des valeurs par défaut. Qu'il s'agisse de définir des propriétés, de renforcer l'immutabilité ou d'adopter 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 de manière harmonieuse. Les constructeurs primaires C# améliorent la clarté et la simplicité de l'initialisation des classes, ce qui les rend précieux pour définir des structures ou des configurations liées aux flux de travail IronPDF.

Tirez parti de la puissance d'IronPDF pour une génération robuste de PDF et utilisez des constructeurs primaires C# lorsque l'élégance de l'initialisation de la 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 efficacité dans le monde vibrant de la programmation C#.

IronPDF offre un service de essai gratuit et sa version allégée license commence à partir de $749.