Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. factory-pattern-csharp
.NET AIDE

Factory Pattern C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Le Factory Pattern en C# est une approche structurelle qui appartient à la catégorie des modèles de conception. Le modèle de conception de méthode de fabrique en C# vise à résoudre des problèmes liés à la création d'objets sans spécifier la classe créatrice exacte de l'objet qui sera créé.

Essentiellement, le modèle de fabrique traite de la création d'objets en la déléguant à une classe spécifique, connue sous le nom de classe de fabrique. Cela permet à un système d'être plus flexible et plus facile à gérer, notamment lors de l'introduction de nouveaux types d'objets, car la classe de fabrique gère le processus de création d'objets, réduisant ainsi la dépendance aux classes concrètes. Explorons comment le modèle de méthode de fabrique, un modèle de conception de création en C#, peut être mis en œuvre et utilisé. Nous explorerons plus tard la bibliothèque de génération de PDF IronPDF.

Structure de base du modèle de méthode de fabrique

L'idée principale du modèle de méthode de fabrique est de définir une interface commune pour créer des objets tout en permettant aux sous-classes de changer le type d'objets qu'elles créent. Ce modèle implique quelques composants clés :

  • Interface Produit : Spécifie la structure des objets créés par la méthode de fabrique.
  • Classes de Produits Concrets : Implémentent l'interface produit.
  • Classe Créatrice (Classe Abstraite Créatrice) : Déclare la méthode de fabrique, qui retourne un objet de l'interface produit.
  • Créateur Concret : Modifie la méthode de fabrique pour fournir une instance du produit concret.

Exemple : Fabrique de véhicules

Considérons un scénario où nous avons différents types de véhicules comme des voitures et des camions. Nous utiliserons le modèle de fabrique pour créer une fabrique de véhicules capable de créer différents types de véhicules en fonction des entrées utilisateur ou d'un fichier de configuration.

Étape 1 : Définir l'Interface Produit

public interface IVehicle
{
    // Method to display information about the vehicle
    void DisplayInfo();
}
public interface IVehicle
{
    // Method to display information about the vehicle
    void DisplayInfo();
}
Public Interface IVehicle
	' Method to display information about the vehicle
	Sub DisplayInfo()
End Interface
$vbLabelText   $csharpLabel

Étape 2 : Implémenter les Produits Concrets

public class Car : IVehicle
{
    // Displays Car specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Car.");
    }
}

public class Truck : IVehicle
{
    // Displays Truck specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Truck.");
    }
}
public class Car : IVehicle
{
    // Displays Car specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Car.");
    }
}

public class Truck : IVehicle
{
    // Displays Truck specific information
    public void DisplayInfo()
    {
        Console.WriteLine("This is a Truck.");
    }
}
Public Class Car
	Implements IVehicle

	' Displays Car specific information
	Public Sub DisplayInfo()
		Console.WriteLine("This is a Car.")
	End Sub
End Class

Public Class Truck
	Implements IVehicle

	' Displays Truck specific information
	Public Sub DisplayInfo()
		Console.WriteLine("This is a Truck.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Étape 3 : Créer la Classe Créatrice Abstraite

public abstract class VehicleFactory
{
    // Factory Method to create a vehicle instance
    public abstract IVehicle CreateVehicle(string type);
}
public abstract class VehicleFactory
{
    // Factory Method to create a vehicle instance
    public abstract IVehicle CreateVehicle(string type);
}
Public MustInherit Class VehicleFactory
	' Factory Method to create a vehicle instance
	Public MustOverride Function CreateVehicle(ByVal type As String) As IVehicle
End Class
$vbLabelText   $csharpLabel

Étape 4 : Implémenter le Créateur Concret

public class ConcreteVehicleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle(string type)
    {
        // Create vehicle based on type
        switch (type.ToLower())
        {
            case "car": return new Car();
            case "truck": return new Truck();
            default: throw new ArgumentException("Invalid vehicle type");
        }
    }
}
public class ConcreteVehicleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle(string type)
    {
        // Create vehicle based on type
        switch (type.ToLower())
        {
            case "car": return new Car();
            case "truck": return new Truck();
            default: throw new ArgumentException("Invalid vehicle type");
        }
    }
}
Public Class ConcreteVehicleFactory
	Inherits VehicleFactory

	Public Overrides Function CreateVehicle(ByVal type As String) As IVehicle
		' Create vehicle based on type
		Select Case type.ToLower()
			Case "car"
				Return New Car()
			Case "truck"
				Return New Truck()
			Case Else
				Throw New ArgumentException("Invalid vehicle type")
		End Select
	End Function
End Class
$vbLabelText   $csharpLabel

Étape 5 : Utilisation du Code Client

class Program
{
    static void Main(string[] args)
    {
        // Create factory instance
        VehicleFactory factory = new ConcreteVehicleFactory();

        // Create a Car and display its info
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();

        // Create a Truck and display its info
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}
class Program
{
    static void Main(string[] args)
    {
        // Create factory instance
        VehicleFactory factory = new ConcreteVehicleFactory();

        // Create a Car and display its info
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();

        // Create a Truck and display its info
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create factory instance
		Dim factory As VehicleFactory = New ConcreteVehicleFactory()

		' Create a Car and display its info
		Dim car As IVehicle = factory.CreateVehicle("car")
		car.DisplayInfo()

		' Create a Truck and display its info
		Dim truck As IVehicle = factory.CreateVehicle("truck")
		truck.DisplayInfo()
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, la classe VehicleFactory sert de créateur abstrait, avec la classe ConcreteVehicleFactory comme créateur concret qui implémente la méthode de fabrique CreateVehicle. Cette méthode décide quel type de véhicule créer en fonction de l'entrée qu'elle reçoit. Le code client utilise alors la fabrique pour créer des instances de différents véhicules, favorisant un couplage lâche entre la logique de création d'objets et le code client.

Factory Pattern C# (Comment ça marche pour les développeurs) : Figure 1 - Sortie du modèle de conception de fabrique

Avantages de l'utilisation du modèle de fabrique

Le modèle de fabrique offre plusieurs avantages, notamment dans les systèmes complexes :

  • Couplage Lâche : Le code client interagit avec des interfaces ou des classes abstraites au lieu de classes de produits concrètes. Cela aboutit à un design plus flexible et plus facile à modifier.
  • Logiciel Orienté Objet Réutilisable : Le modèle de fabrique favorise la réutilisation du code car il sépare la logique de création d'objets du système, rendant le système plus facile à maintenir et à étendre.
  • Flexibilité dans la Création d'Objets : La méthode de fabrique permet différentes implémentations pour créer des objets, qui peuvent être sélectionnées à l'exécution. Cela est particulièrement utile dans les scénarios où le type d'objets requis peut varier en fonction de facteurs externes.

IronPDF : Solution PDF .NET

Factory Pattern C# (Comment ça marche pour les développeurs) : Figure 2 - IronPDF

IronPDF est une bibliothèque conçue pour la plateforme .NET, aidant les développeurs à créer, éditer et manipuler facilement des fichiers PDF directement à partir de HTML, CSS, images et JavaScript, sans plonger dans les APIs complexes de génération de PDF. Son principal attrait réside dans sa capacité à transformer le contenu web en documents PDF rapidement et avec une grande précision, grâce à son utilisation d'un moteur de rendu basé sur Chrome.

Les fonctionnalités clés incluent la génération de PDF à partir de chaînes ou d'URLs HTML, le rendu de pages web en PDF à la volée, et la capacité de travailler avec des applications forms, des applications serveur et des intranets sécurisés, entre autres. Sa performance est optimisée pour l'efficacité, avec des capacités d'opérations asynchrones, de journalisation personnalisée et une documentation complète pour vous aider à démarrer rapidement.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        // Initialize a Pdf Renderer with a Chrome Rendering Engine
        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)
    {
        // Initialize a Pdf Renderer with a Chrome Rendering Engine
        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)
		' Initialize a Pdf Renderer with a Chrome Rendering Engine
		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

Exemple de code

Pour illustrer comment IronPDF peut être intégré avec le modèle de fabrique, créons un exemple simplifié. Le modèle de fabrique est un type de modèle de conception de création qui offre un moyen de créer des produits ou objets concrets au sein d'une super classe, permettant aux sous-classes de modifier les objets spécifiques être produits. Cela convient bien pour créer différents types de documents PDF selon des besoins spécifiques, tels que des chaînes HTML, des URLs ou des fichiers.

Nous créerons une interface nommée IPdfCreator qui définit une méthode pour créer des PDF, puis nous implémenterons différentes classes de fabrique qui créent des PDF de diverses manières en utilisant IronPDF.

Étape 1 : Définir l'Interface IPdfCreator

Cette interface déclare la méthode CreatePdf que toutes les fabriques concrètes vont implémenter.

public interface IPdfCreator
{
    // Method responsible for creating a PDF
    void CreatePdf(string source);
}
public interface IPdfCreator
{
    // Method responsible for creating a PDF
    void CreatePdf(string source);
}
Public Interface IPdfCreator
	' Method responsible for creating a PDF
	Sub CreatePdf(ByVal source As String)
End Interface
$vbLabelText   $csharpLabel

Étape 2 : Implémenter les Fabriques Concrètes

Ici, nous définissons deux implémentations concrètes de IPdfCreator : une pour créer des PDF à partir de chaînes HTML et une autre à partir d'URLs.

public class HtmlStringPdfCreator : IPdfCreator
{
    // Creates a PDF from an HTML string
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}

// Create PDF from a given URL
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}
public class HtmlStringPdfCreator : IPdfCreator
{
    // Creates a PDF from an HTML string
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}

// Create PDF from a given URL
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}
Public Class HtmlStringPdfCreator
	Implements IPdfCreator

	' Creates a PDF from an HTML string
	Public Sub CreatePdf(ByVal htmlString As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlString)
		pdf.SaveAs("HtmlStringPdf.pdf")
	End Sub
End Class

' Create PDF from a given URL
Public Class UrlPdfCreator
	Implements IPdfCreator

	Public Sub CreatePdf(ByVal url As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderUrlAsPdf(url)
		pdf.SaveAs("UrlPdf.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Étape 3 : Utiliser la Fabrique

Dans votre application, vous pouvez maintenant utiliser ces fabriques pour créer des documents PDF à partir de différentes sources sans vous soucier des détails du processus de création de PDF.

class Program
{
    static void Main(string[] args)
    {
        // Add your IronPDF license key
        License.LicenseKey = "License-Key";

        // Create PDF from HTML string
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");

        // Create PDF from URL
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}
class Program
{
    static void Main(string[] args)
    {
        // Add your IronPDF license key
        License.LicenseKey = "License-Key";

        // Create PDF from HTML string
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");

        // Create PDF from URL
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Add your IronPDF license key
		License.LicenseKey = "License-Key"

		' Create PDF from HTML string
		Dim htmlPdfCreator As IPdfCreator = New HtmlStringPdfCreator()
		htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>")

		' Create PDF from URL
		Dim urlPdfCreator As IPdfCreator = New UrlPdfCreator()
		urlPdfCreator.CreatePdf("http://example.com")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cette configuration, HtmlStringPdfCreator et UrlPdfCreator sont des fabriques concrètes qui produisent des PDF. La classe Program, agissant en tant que client, utilise ces fabriques sans avoir besoin de connaître les détails complexes sur la façon dont les PDFs sont générés à partir de chaînes HTML ou d'URLs. Cette approche offre de la flexibilité, car vous pouvez introduire de nouvelles façons de créer des PDF (par exemple, à partir de fichiers ou de flux) simplement en ajoutant plus de fabriques qui implémentent l'interface IPdfCreator, suivant le principe Ouvert/Fermé de la conception orientée objet.

Sortie

Les captures d'écran suivantes sont la sortie du code :

Factory Pattern C# (Comment ça marche pour les développeurs) : Figure 3 - Sortie du Modèle de Conception de Fabrique de PDF

Factory Pattern C# (Comment ça marche pour les développeurs) : Figure 4 - Sortie de la Méthode de Fabrique de Base

Conclusion

Factory Pattern C# (Comment ça marche pour les développeurs) : Figure 5 - Licences

Le modèle de fabrique en C# fournit un cadre pour gérer la création d'objets, rendant la conception logicielle plus maintenable et extensible. En utilisant des classes concrètes pour implémenter une fabrique abstraite et déléguer la logique de création, les développeurs peuvent créer des systèmes plus faciles à adapter et à étendre. Que ce soit pour quelques classes ou un système avec des dépendances complexes, le modèle de fabrique offre une approche structurée pour la création d'objets de classe exacte. Il est particulièrement bénéfique dans les scénarios où le type d'objets à créer peut varier en fonction des entrées utilisateur, de la configuration ou de l'état de l'application.

IronPDF offre une version d'essai gratuite de IronPDF pour commencer, et les options de licence commencent à liteLicense, répondant ainsi aux développeurs souhaitant intégrer des fonctionnalités PDF dans leurs applications .NET.

Questions Fréquemment Posées

Comment le modèle de fabrique peut-il être appliqué dans le développement en C# ?

Le modèle de fabrique peut être appliqué dans le développement en C# en créant une classe de fabrique qui gère l'instanciation des objets. Cette approche permet aux développeurs de définir une interface pour créer un objet, mais laisse les sous-classes modifier le type d'objets qui seront créés, favorisant un couplage lâche et une flexibilité du système.

Quel rôle joue le modèle de fabrique dans la conception logicielle ?

Le modèle de fabrique joue un rôle crucial dans la conception logicielle en fournissant un moyen de déléguer l'instanciation des objets à une classe de fabrique. Cela aide à séparer la logique de création de la logique métier, rendant le système plus facile à gérer et à étendre.

Comment les développeurs peuvent-ils utiliser IronPDF pour créer des documents PDF en C# ?

Les développeurs peuvent utiliser IronPDF pour créer des documents PDF en C# en tirant parti de son moteur de rendu basé sur Chrome. En utilisant des méthodes telles que RenderHtmlAsPdf ou RenderUrlAsPdf, des chaînes HTML ou des pages web peuvent être converties en documents PDF de haute qualité sans effort.

Quels sont les avantages d'utiliser une bibliothèque PDF .NET comme IronPDF ?

Utiliser une bibliothèque PDF .NET comme IronPDF offre de nombreux avantages, y compris la capacité de créer, éditer et manipuler des PDFs à partir de diverses entrées comme HTML, CSS, images, et JavaScript. Elle supporte les opérations asynchrones et aide à maintenir la mise en page et les styles d'origine du contenu web dans les PDFs.

Comment le modèle de fabrique peut-il améliorer la génération de documents PDF ?

Le modèle de fabrique améliore la génération de documents PDF en permettant aux développeurs de définir une interface commune pour créer des PDFs à partir de différentes sources, telles que des chaînes HTML, des URLs ou des fichiers. Cela permet d'ajouter de nouveaux types de PDFs sans altérer le code existant, respectant ainsi le principe Open/Closed.

Dans quels scénarios le modèle de fabrique est-il le plus utile ?

Le modèle de fabrique est le plus utile dans les scénarios où un système doit gérer la création d'objets de manière dynamique, basée sur l'entrée de l'utilisateur ou la configuration. Il est particulièrement bénéfique dans les applications qui nécessitent des changements fréquents ou des extensions du processus de création d'objets.

Quelle est l'importance du modèle de fabrique dans le maintien de la flexibilité logicielle ?

L'importance du modèle de fabrique dans le maintien de la flexibilité logicielle réside dans sa capacité à séparer la création d'objets de la logique métier. Cela permet aux développeurs d'introduire de nouveaux types d'objets sans modifier le code existant, maintenant ainsi une architecture flexible et extensible.

Comment IronPDF prend-il en charge le modèle de fabrique dans la création de documents ?

IronPDF prend en charge le modèle de fabrique dans la création de documents en permettant aux développeurs d'implémenter le modèle via ses interfaces et méthodes. Par exemple, en utilisant ChromePdfRenderer avec différents types d'entrée, les développeurs peuvent créer diverses formes de documents PDF sans altérer la logique de création sous-jacente.

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