Factory Pattern C# (Wie es für Entwickler funktioniert)

Die Factory-Muster in C# ist ein struktureller Ansatz, der zur Kategorie der Entwurfsmuster gehört. Das Factory-Methodenentwurfsmuster in C# zielt darauf ab, Probleme im Zusammenhang mit der Erstellung von Objekten zu lösen, ohne die genaue Erzeugerklasse des zu erstellenden Objekts anzugeben.

Im Wesentlichen befasst sich das Factory-Pattern mit der Objekterstellung, indem es diese an eine bestimmte Klasse, die so genannte Factory-Klasse, delegiert. Dadurch wird ein System flexibler und einfacher zu verwalten, insbesondere bei der Einführung neuer Objekttypen, da die Fabrikklasse den Prozess der Objekterstellung übernimmt und die Abhängigkeit von den konkreten Klassen verringert. Lassen Sie uns eintauchen, wie das Factory-Methodenmuster, ein kreatives Entwurfsmuster in C#, implementiert und verwendet werden kann. Wir erforschen die IronPDF-Bibliothek später.

Grundlegende Struktur des Fabrikmethoden-Musters

Die Kernidee hinter dem Factory-Methoden-Muster besteht darin, eine gemeinsame Schnittstelle für die Erstellung von Objekten zu definieren und gleichzeitig Unterklassen die Möglichkeit zu geben, den Typ der von ihnen erstellten Objekte zu ändern. Dieses Muster umfasst einige Schlüsselkomponenten: abstraktes Fabrikmuster, kreative Entwurfsmuster, Fabrikentwurfsmuster, vorhandener Code, grundlegendes Fabrikmuster, abstrakte Fabrikmuster, Beispiele aus der Praxis, konkretes Produkt, verwandte oder abhängige Objekte und konkrete Klasse.

• Produkt-Schnittstelle: Gibt die Struktur von Objekten an, die mit der Fabrikmethode erstellt werden.
• Konkrete Produktklassen: Implementieren die Produktschnittstelle.
• Schöpferklasse (Schöpfer abstrakter Klassen): Deklariert die Fabrikmethode, die ein Objekt der Produktschnittstelle zurückgibt.
• Concrete Creator: Ändert die Fabrikmethode, um eine Instanz des konkreten Produkts zu liefern.

Beispiel: Fahrzeugfabrik

Stellen Sie sich ein Szenario vor, in dem wir verschiedene Fahrzeugtypen wie Autos und Lastwagen haben. Wir werden das Fabrikmuster verwenden, um eine Fahrzeugfabrik zu erstellen, die auf der Grundlage von Benutzereingaben oder einer Konfigurationsdatei verschiedene Fahrzeugtypen erzeugen kann.

Schritt 1: Definieren Sie die Produktschnittstelle

public interface IVehicle
{
    void DisplayInfo();
}

public interface IVehicle
{
    void DisplayInfo();
}

Public Interface IVehicle
	Sub DisplayInfo()
End Interface

Schritt 2: Konkrete Produkte einsetzen

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

Schritt 3: Erstellen der abstrakten Creator-Klasse

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

Schritt 4: Implementierung des Concrete Creators

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

Schritt 5: Client-Code-Verwendung

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

Im obigen Beispiel dient die Klasse VehicleFactory als abstrakter Ersteller, während die Klasse ConcreteVehicleFactory der konkrete Ersteller ist, der die Fabrikmethode CreateVehicle implementiert. Diese Methode entscheidet auf der Grundlage der empfangenen Eingaben, welcher Fahrzeugtyp zu erstellen ist. Der Client-Code verwendet dann die Fabrik, um Instanzen verschiedener Fahrzeuge zu erstellen, was eine lose Kopplung zwischen der Objekterstellungslogik und dem Client-Code fördert.

Vorteile der Verwendung des Factory-Patterns

Das Fabrikmuster bietet mehrere Vorteile, insbesondere in komplexen Systemen:

• Lose Kopplung: Der Client-Code interagiert mit Schnittstellen oder abstrakten Klassen anstelle von konkreten Produktklassen. Das Ergebnis ist ein flexibleres und leichter zu änderndes Design.
• Wiederverwendbare objektorientierte Software: Das Factory-Pattern fördert die Wiederverwendung von Code, da es die Logik der Objekterzeugung vom System trennt, wodurch das System leichter zu warten und zu erweitern ist.
• Flexibilität bei der Objekterzeugung: Die Factory-Methode erlaubt verschiedene Implementierungen für die Erstellung von Objekten, die zur Laufzeit ausgewählt werden können. Dies ist besonders in Szenarien nützlich, in denen die Art der benötigten Objekte aufgrund externer Faktoren variieren kann.

IronPDF: .NET PDF-Lösung

IronPDF ist eine Bibliothek für die .NET-Plattform, die Entwicklern das einfache Erstellen, Bearbeiten und Verändern von PDF-Dateien direkt aus HTMLcSS, Bilder und JavaScript, ohne in komplexe PDF-Generierungs-APIs einzutauchen. Seine Hauptattraktion liegt in der Fähigkeit, Webinhalte dank einer Chrome-basierten Rendering-Engine schnell und mit hoher Genauigkeit in PDF-Dokumente umzuwandeln.

Zu den wichtigsten Funktionen gehören die Generierung von PDFs aus HTML-Strings oder URLs, die sofortige Umwandlung von Webseiten in PDFs und die Fähigkeit, mit Formularanwendungen, Serveranwendungen und sicheren Intranets zu arbeiten. Die Leistung ist auf Effizienz optimiert und bietet Funktionen für asynchrone Vorgänge, benutzerdefinierte Protokollierung und eine ausführliche Dokumentation, die Ihnen einen schnellen Einstieg ermöglicht.

Code-Beispiel

Um zu veranschaulichen, wie IronPDF mit dem Factory Pattern integriert werden kann, wollen wir ein vereinfachtes Beispiel erstellen. Das Factory Pattern ist eine Art Entwurfsmuster, das eine Möglichkeit bietet, konkrete Produkte oder Objekte innerhalb einer Oberklasse zu erstellen, wobei Unterklassen die Möglichkeit haben, die erzeugten spezifischen Objekte zu ändern. Dies eignet sich gut für die Erstellung verschiedener Arten von PDF-Dokumenten auf der Grundlage spezifischer Anforderungen, z. B. aus HTML-Strings, URLs oder Dateien.

Wir werden eine Schnittstelle mit dem Namen IPdfCreator erstellen, die eine Methode zur Erstellung von PDFs definiert, und dann verschiedene Fabrikklassen implementieren, die PDFs auf verschiedene Weise mit IronPDF erstellen.

Schritt 1: Definieren Sie die IPdfCreator-Schnittstelle

Diese Schnittstelle deklariert die Methode CreatePdf, die von allen konkreten Factories implementiert wird.

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

Schritt 2: Implementierung von Betonfabriken

Hier definieren wir zwei konkrete Implementierungen von IPdfCreator: eine für die Erstellung von PDFs aus HTML-Zeichenfolgen und eine weitere aus URLs.

// 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

Schritt 3: Verwendung des Werks

In Ihrer Anwendung können Sie nun diese Fabriken verwenden, um PDF-Dokumente aus verschiedenen Quellen zu erstellen, ohne sich um die Details des PDF-Erstellungsprozesses kümmern zu müssen.

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

In dieser Konfiguration sind HtmlStringPdfCreator und UrlPdfCreator konkrete Fabriken, die PDFs erzeugen. Die Klasse Programm, die als Client fungiert, verwendet diese Fabriken, ohne die komplizierten Details zu kennen, wie PDFs aus HTML-Strings oder URLs erzeugt werden. Dieser Ansatz bietet Flexibilität, da Sie neue Methoden zur Erstellung von PDFs einführen können (z.B. aus Dateien oder Streams) einfach durch Hinzufügen weiterer Factories, die die Schnittstelle IPdfCreator implementieren, nach dem Open/Closed-Prinzip des objektorientierten Designs.

Ausgabe

Die folgenden Bildschirmfotos zeigen die Ausgabe des Codes:

Schlussfolgerung

Das Factory-Pattern in C# bietet einen Rahmen für die Verwaltung der Objekterstellung, wodurch das Softwaredesign wartbarer und erweiterbar wird. Durch die Verwendung konkreter Klassen zur Implementierung einer abstrakten Fabrik- und Delegatenerstellungslogik können Entwickler Systeme erstellen, die sich leichter anpassen und erweitern lassen. Unabhängig davon, ob es sich um einige wenige Klassen oder ein System mit komplexen Abhängigkeiten handelt, bietet das Factory-Pattern einen strukturierten Ansatz für die Erstellung exakter Klassenobjekte. Dies ist besonders in Szenarien von Vorteil, in denen die Art der zu erstellenden Objekte je nach Benutzereingabe, Konfiguration oder Anwendungsstatus variieren kann.

IronPDF bietet eine kostenloser Test die Lizenzoptionen beginnen bei $749 und richten sich an Entwickler, die PDF-Funktionen in ihre .NET-Anwendungen integrieren möchten.