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

Das Factory Pattern 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 Erstellung von Objekten, indem es diese an eine bestimmte Klasse, die sogenannte 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 werden die IronPDF PDF Generation Library später erkunden.

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.

• Produktinterface: Gibt die Struktur von Objekten an, die durch die Fabrikmethode erstellt werden.
• Konkrete Produktklassen: Implementieren Sie die Produkt-Schnittstelle.
• Creator-Klasse (Abstrakte Klasse Creator): Deklariert die Fabrikmethode, die ein Objekt der Produkt-Schnittstelle zurückgibt.
• Konkreter Ersteller: Passt die Fabrikmethode an, um eine Instanz des konkreten Produkts bereitzustellen.

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 VehicleFactory-Klasse als abstrakter Ersteller, wobei die ConcreteVehicleFactory-Klasse 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 konkreter 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 Objekterstellung vom System trennt, was das System leichter wartbar und erweiterbar macht.
• Flexibilität bei der Objekterstellung: Die Fabrikmethode ermöglicht verschiedene Implementierungen zur Erstellung von Objekten, die zur Laufzeit ausgewählt werden können. Dies ist besonders nützlich in Szenarien, in denen der benötigte Objekttyp aufgrund externer Faktoren variieren kann.

IronPDF: .NET PDF-Lösung

IronPDF ist eine Bibliothek, die für die .NET-Plattform entwickelt wurde und Entwicklern hilft, PDF-Dateien direkt aus HTML, CSS, Bildern und JavaScript einfach zu erstellen, zu bearbeiten und zu manipulieren, ohne in komplexe PDF-Generierungs-APIs eintauchen zu müssen. Der Hauptanziehungspunkt liegt in der Fähigkeit, Webinhalte schnell und mit hoher Genauigkeit in PDF-Dokumente zu transformieren, dank des Einsatzes einer auf Chrome basierenden Rendering-Engine.

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.

IronPDF zeichnet sich durch die HTML-zu-PDF-Konvertierung aus und gewährleistet eine präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist perfekt geeignet, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. Mit Unterstützung von HTML-Dateien, URLs und rohen HTML-Zeichenfolgen produziert IronPDF mühelos hochwertige PDF-Dokumente.

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");
    }
}

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

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 erstellen eine Schnittstelle namens IPdfCreator, die eine Methode zum Erstellen von PDFs definiert, und implementieren dann verschiedene Fabrikklassen, die mit IronPDF auf unterschiedliche Weise PDFs erstellen.

Schritt 1: Definieren Sie die IPdfCreator-Schnittstelle

Diese Schnittstelle deklariert die CreatePdf-Methode, die alle konkreten Fabriken implementieren werden.

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 zum Erstellen von PDFs aus HTML-Strings und eine andere 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 Einrichtung sind HtmlStringPdfCreator und UrlPdfCreator konkrete Fabriken, die PDFs erzeugen. Die Program-Klasse, die als Client fungiert, verwendet diese Fabriken, ohne dass sie die komplizierten Details kennen muss, wie PDFs aus HTML-Strings oder URLs generiert werden. Dieser Ansatz bietet Flexibilität, da Sie neue Möglichkeiten zur Erstellung von PDFs (z. B. aus Dateien oder Streams) einfach hinzufügen können, indem Sie weitere Fabriken hinzufügen, die das IPdfCreator-Interface implementieren, und dabei das Open/Closed-Prinzip des objektorientierten Designs befolgen.

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 kostenlose Testversion von IronPDF an, um loszulegen, und die Lizenzierungsoptionen beginnen bei $749, um Entwicklern, die PDF-Funktionen in ihre .NET-Anwendungen integrieren möchten, entgegenzukommen.