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

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

Essentiellement, le modèle d'usine traite de la création d'objets en la déléguant à une classe spécifique, connue sous le nom de classe d'usine. Cela permet à un système d'être plus flexible et plus facile à gérer, en particulier lors de l'introduction de nouveaux types d'objets, car la classe d'usine gère le processus de création d'objets, réduisant ainsi la dépendance vis-à-vis des classes concrètes. Voyons maintenant comment mettre en œuvre et utiliser le modèle de la méthode factory, un modèle de conception créative en C#. Nous explorerons les Bibliothèque IronPDF plus tard.

Structure du modèle de la méthode d'usine de base

L'idée centrale du modèle de la méthode factory est de définir une interface commune pour la création d'objets tout en permettant aux sous-classes de modifier le type d'objets qu'elles créent. Ce modèle comporte quelques éléments clés : modèle d'usine abstraite, modèles de conception créative, modèle d'usine, code existant, modèle d'usine de base, modèles d'usine abstraite, exemples du monde réel, produit concret, objets liés ou dépendants, et classe concrète.

• Interface produit : Spécifie la structure des objets créés par la méthode factory.
• Classes de produits concrets : Implémentation de l'interface produit.
• Classe des créateurs (Créateur de classes abstraites) : Déclare la méthode factory, qui renvoie un objet de l'interface product.
• Créateur de béton : Modifie la méthode de fabrication pour fournir une instance du produit concret.

Exemple : Usine de véhicules

Prenons un scénario dans lequel 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 qui peut créer différents types de véhicules en fonction des données de l'utilisateur ou d'un fichier de configuration.

Étape 1 : Définir l'interface du produit

public interface IVehicle
{
    void DisplayInfo();
}

public interface IVehicle
{
    void DisplayInfo();
}

Public Interface IVehicle
	Sub DisplayInfo()
End Interface

Étape 2 : Mise en œuvre de produits concrets

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

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

Public Class Car
	Implements IVehicle

	Public Sub DisplayInfo()
		Console.WriteLine("This is a Car.")
	End Sub
End Class
Public Class Truck
	Implements IVehicle

	Public Sub DisplayInfo()
		Console.WriteLine("This is a Truck.")
	End Sub
End Class

Étape 3 : Créer la classe abstraite de créateur

public abstract class VehicleFactory
{
    public abstract IVehicle CreateVehicle(string type);
}

public abstract class VehicleFactory
{
    public abstract IVehicle CreateVehicle(string type);
}

Public MustInherit Class VehicleFactory
	Public MustOverride Function CreateVehicle(ByVal type As String) As IVehicle
End Class

Étape 4 : Mise en œuvre du créateur de béton

public class ConcreteVehicleFactory : VehicleFactory
{
    public override IVehicle CreateVehicle(string 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)
    {
        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
		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

Étape 5 : Utilisation du code client

class Program
{
    static void Main(string [] args)
    {
        // create objects
        VehicleFactory factory = new ConcreteVehicleFactory();
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}

class Program
{
    static void Main(string [] args)
    {
        // create objects
        VehicleFactory factory = new ConcreteVehicleFactory();
        IVehicle car = factory.CreateVehicle("car");
        car.DisplayInfo();
        IVehicle truck = factory.CreateVehicle("truck");
        truck.DisplayInfo();
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' create objects
		Dim factory As VehicleFactory = New ConcreteVehicleFactory()
		Dim car As IVehicle = factory.CreateVehicle("car")
		car.DisplayInfo()
		Dim truck As IVehicle = factory.CreateVehicle("truck")
		truck.DisplayInfo()
	End Sub
End Class

Dans l'exemple ci-dessus, la classe VehicleFactory sert de créateur abstrait, la classe ConcreteVehicleFactory étant le créateur concret qui implémente la méthode de fabrication CreateVehicle. Cette méthode décide du type de véhicule à créer en fonction des données qu'elle reçoit. Le code client utilise ensuite la fabrique pour créer des instances de différents véhicules, ce qui favorise un couplage lâche entre la logique de création d'objets et le code client.

Avantages de l'utilisation du modèle d'usine

Le modèle d'usine offre plusieurs avantages, en particulier dans les systèmes complexes :

• Couplage souple : Le code du client interagit avec des interfaces ou des classes abstraites au lieu de classes de produits concrètes. Il en résulte une conception plus souple et plus facile à modifier.
• Logiciel orienté objet réutilisable : Le modèle d'usine favorise la réutilisation du code car il sépare la logique de création des objets du système, ce qui facilite la maintenance et l'extension de ce dernier.
• Flexibilité dans la création d'objets : La méthode factory permet différentes implémentations pour la création d'objets, qui peuvent être sélectionnées au moment de l'exécution. Ceci 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

IronPDF est une bibliothèque conçue pour la plate-forme .NET, qui aide les développeurs à créer, éditer et manipuler facilement des fichiers PDF Fichiers PDF directement à partir de HTMLl'application permet de créer des documents PDF à partir d'images, de feuilles de style CSS, d'images et de JavaScript, sans avoir recours à des API de génération de PDF complexes. Son principal attrait réside dans sa capacité à transformer du contenu web en documents PDF rapidement et avec une grande précision, grâce à l'utilisation d'un moteur de rendu basé sur Chrome.

Ses principales caractéristiques sont la génération de PDF à partir de chaînes HTML ou d'URL, le rendu de pages web en PDF à la volée et la capacité de travailler avec des applications de formulaires, des applications serveur et des intranets sécurisés, entre autres. Ses performances sont optimisées pour l'efficacité, avec des possibilités d'opérations asynchrones, une journalisation personnalisée et une documentation complète pour vous aider à démarrer rapidement.

Exemple de code

Pour illustrer la façon dont IronPDF peut être intégré avec le Factory Pattern, créons un exemple simplifié. Le modèle d'usine est un type de modèle de conception créative qui offre un moyen de créer des produits ou des objets concrets au sein d'une superclasse, permettant aux sous-classes de modifier les objets spécifiques produits. Cela permet de créer différents types de documents PDF en fonction de besoins spécifiques, par exemple à partir de chaînes HTML, d'URL ou de fichiers.

Nous allons créer une interface nommée IPdfCreator qui définit une méthode de création de PDF, puis implémenter différentes classes d'usine qui créent des PDF de différentes manières à l'aide d'IronPDF.

Étape 1 : Définir l'interface IPdfCreator

Cette interface déclare la méthode CreatePdf que toutes les usines concrètes mettront en œuvre.

public interface IPdfCreator
{
    void CreatePdf(string source);
}

public interface IPdfCreator
{
    void CreatePdf(string source);
}

Public Interface IPdfCreator
	Sub CreatePdf(ByVal source As String)
End Interface

Étape 2 : Mettre en place des usines de béton

Nous définissons ici deux implémentations concrètes de IPdfCreator : l'une pour créer des PDF à partir de chaînes HTML et l'autre à partir d'URL.

// public class
public class HtmlStringPdfCreator : IPdfCreator
{
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}

// public class
public class HtmlStringPdfCreator : IPdfCreator
{
    public void CreatePdf(string htmlString)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlString);
        pdf.SaveAs("HtmlStringPdf.pdf");
    }
}
public class UrlPdfCreator : IPdfCreator
{
    public void CreatePdf(string url)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("UrlPdf.pdf");
    }
}

' public class
Public Class HtmlStringPdfCreator
	Implements IPdfCreator

	Public Sub CreatePdf(ByVal htmlString As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlString)
		pdf.SaveAs("HtmlStringPdf.pdf")
	End Sub
End Class
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

Étape 3 : Utilisation de l'usine

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

class Program
{
    static void Main(string [] args)
    {
    License.LicenseKey = "License-Key";
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}

class Program
{
    static void Main(string [] args)
    {
    License.LicenseKey = "License-Key";
        IPdfCreator htmlPdfCreator = new HtmlStringPdfCreator();
        htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>");
        IPdfCreator urlPdfCreator = new UrlPdfCreator();
        urlPdfCreator.CreatePdf("http://example.com");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
	License.LicenseKey = "License-Key"
		Dim htmlPdfCreator As IPdfCreator = New HtmlStringPdfCreator()
		htmlPdfCreator.CreatePdf("<h1>Hello, World!</h1>")
		Dim urlPdfCreator As IPdfCreator = New UrlPdfCreator()
		urlPdfCreator.CreatePdf("http://example.com")
	End Sub
End Class

Dans cette configuration, HtmlStringPdfCreator et UrlPdfCreator sont des usines concrètes qui produisent des PDF. La classe Programme, agissant en tant que client, utilise ces usines sans avoir besoin de connaître les détails complexes de la manière dont les PDF sont générés à partir de chaînes HTML ou d'URL. Cette approche offre une certaine souplesse, car elle permet d'introduire de nouvelles méthodes de création de PDF (par exemple, à partir de fichiers ou de flux) simplement en ajoutant des usines qui implémentent l'interface IPdfCreator, en suivant le principe ouvert/fermé de la conception orientée objet.

Sortie

Les captures d'écran suivantes sont le résultat du code :

Conclusion

Le modèle d'usine en C# fournit un cadre pour la gestion de la création d'objets, ce qui rend la conception de logiciels plus facile à maintenir et plus extensible. En utilisant des classes concrètes pour mettre en œuvre une logique abstraite de création d'usines et de délégués, les développeurs peuvent créer des systèmes plus faciles à adapter et à étendre. Qu'il s'agisse de quelques classes ou d'un système avec des dépendances complexes, le modèle de la fabrique offre une approche structurée de la création d'objets de classe exacts. Il est particulièrement utile dans les scénarios où le type d'objets à créer peut varier en fonction des entrées de l'utilisateur, de la configuration ou de l'état de l'application.

IronPDF offre un service de essai gratuit pour commencer, et les options de licence commencent à 749 $, pour les développeurs qui cherchent à intégrer des fonctionnalités PDF dans leurs applications .NET.