Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. factory-pattern-csharp
.NET AYUDA

Patrón de Fábrica C# (Cómo Funciona para Desarrolladores)

Curtis Chau
Curtis Chau
Actualizado:

The Factory Pattern in C# is a structural approach that belongs to the category of design patterns. The Factory Method Design Pattern in C# is aimed at solving problems related to creating objects without specifying the exact creator class of the object that will be created.

Essentially, the factory pattern deals with object creation by delegating it to a specific class, known as the factory class. This enables a system to be more flexible and easier to manage, especially when introducing new types of objects, as the factory class handles the object creation process, reducing the dependency on the concrete classes. Let's dive into how the Factory Method Pattern, a creational design pattern in C#, can be implemented and used. We'll explore the IronPDF PDF Generation Library later.

Basic Factory Method Pattern Structure

The core idea behind the factory method pattern is to define a common interface for creating objects while allowing subclasses to change the type of objects they create. This pattern involves a few key components:

  • Product Interface: Specifies the structure of objects created by the factory method.
  • Concrete Product Classes: Implement the product interface.
  • Creator Class (Abstract Class Creator): Declares the factory method, which returns an object of the product interface.
  • Concrete Creator: Modifies the factory method to deliver an instance of the concrete product.

Example: Vehicle Factory

Consider a scenario where we have different types of vehicles like cars and trucks. We'll use the factory pattern to create a vehicle factory that can create different types of vehicles based on user input or a configuration file.

Step 1: Define the Product Interface

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

Step 2: Implement Concrete Products

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

Step 3: Create the Abstract Creator Class

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

Step 4: Implement the Concrete Creator

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

Step 5: Client Code Usage

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

In the above example, the VehicleFactory class serves as the abstract creator, with the ConcreteVehicleFactory class being the concrete creator that implements the factory method CreateVehicle. This method decides which type of vehicle to create based on the input it receives. The client code then uses the factory to create instances of different vehicles, promoting loose coupling between the object creation logic and the client code.

Factory Pattern C# (How It Works For Developers): Figure 1 - Factory Design Pattern Output

Advantages of Using the Factory Pattern

The factory pattern offers several advantages, especially in complex systems:

  • Loose Coupling: The client code interacts with interfaces or abstract classes instead of concrete product classes. This results in a design that is more flexible and easier to modify.
  • Reusable Object-Oriented Software: The factory pattern promotes the reuse of code as it separates the object creation logic from the system, making the system easier to maintain and extend.
  • Flexibility in Object Creation: The factory method allows different implementations for creating objects, which can be selected at runtime. This is especially useful in scenarios where the type of objects required can vary based on external factors.

IronPDF: .NET PDF Solution

Factory Pattern C# (How It Works For Developers): Figure 2 - IronPDF

IronPDF is a library designed for the .NET platform, helping developers easily create, edit, and manipulate PDF files directly from HTML, CSS, images, and JavaScript, without diving into complex PDF generation APIs. Its main attraction lies in its ability to transform web content into PDF documents swiftly and with high accuracy, thanks to its use of a Chrome-based rendering engine.

Key features include generating PDFs from HTML strings or URLs, rendering web pages as PDFs on the fly, and the ability to work with forms applications, server applications, and secure intranets among others. Its performance is optimized for efficiency, with capabilities for asynchronous operations, custom logging, and extensive documentation to help get you started quickly.

IronPDF excels in HTML to PDF conversion, ensuring precise preservation of original layouts and styles. It's perfect for creating PDFs from web-based content such as reports, invoices, and documentation. With support for HTML files, URLs, and raw HTML strings, IronPDF easily produces high-quality PDF documents.

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

Code Example

To illustrate how IronPDF can be integrated with the Factory Pattern, let's create a simplified example. The Factory Pattern is a type of creational design pattern that offers a way to create concrete products or objects within a superclass, permitting subclasses to modify the specific objects being produced. This fits well with creating different types of PDF documents based on specific needs, such as from HTML strings, URLs, or files.

We'll create an interface named IPdfCreator that defines a method for creating PDFs, and then implement different factory classes that create PDFs in various ways using IronPDF.

Step 1: Define the IPdfCreator Interface

This interface declares the CreatePdf method that all concrete factories will implement.

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

Step 2: Implement Concrete Factories

Here we define two concrete implementations of IPdfCreator: one for creating PDFs from HTML strings and another from 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

Step 3: Using the Factory

In your application, you can now use these factories to create PDF documents from different sources without worrying about the details of the PDF creation process.

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

In this setup, HtmlStringPdfCreator and UrlPdfCreator are concrete factories that produce PDFs. The Program class, acting as a client, uses these factories without needing to know the intricate details of how PDFs are generated from HTML strings or URLs. This approach provides flexibility, as you can introduce new ways of creating PDFs (e.g., from files or streams) simply by adding more factories that implement the IPdfCreator interface, following the Open/Closed Principle of object-oriented design.

Output

The following screenshots are the output of the code:

Factory Pattern C# (How It Works For Developers): Figure 3 - Factory Design Pattern PDF Output

Factory Pattern C# (How It Works For Developers): Figure 4 - Base Factory Method Output

Conclusion

Factory Pattern C# (How It Works For Developers): Figure 5 - Licensing

The factory pattern in C# provides a framework for managing object creation, making software design more maintainable and extensible. By using concrete classes to implement an abstract factory and delegate creation logic, developers can create systems that are easier to adapt and expand. Whether dealing with a few classes or a system with complex dependencies, the factory pattern offers a structured approach to exact class object creation. It's particularly beneficial in scenarios where the type of objects to be created can vary based on user input, configuration, or application state.

IronPDF offers a free trial of IronPDF to get started, and license options begin at liteLicense, catering to developers looking to integrate PDF functionalities into their .NET applications.

Preguntas Frecuentes

¿Cómo se puede aplicar el patrón Factory en el desarrollo de C#?

El patrón Factory se puede aplicar en el desarrollo de C# creando una clase fábrica que gestiona la instanciación de objetos. Este enfoque permite a los desarrolladores definir una interfaz para crear un objeto, pero dejar que las subclases alteren el tipo de objetos que se crearán, promoviendo un acoplamiento débil y la flexibilidad del sistema.

¿Qué papel juega el patrón Factory en el diseño de software?

El patrón Factory juega un papel crucial en el diseño de software al proporcionar una forma de delegar la instanciación de objetos a una clase fábrica. Esto ayuda a separar la lógica de creación de la lógica de negocio, haciendo que el sistema sea más manejable y fácil de extender.

¿Cómo pueden los desarrolladores usar IronPDF para crear documentos PDF en C#?

Los desarrolladores pueden usar IronPDF para crear documentos PDF en C# aprovechando su motor de renderizado basado en Chrome. Al utilizar métodos como RenderHtmlAsPdf o RenderUrlAsPdf, las cadenas HTML o las páginas web pueden convertirse en documentos PDF de alta calidad sin esfuerzo.

¿Cuáles son los beneficios de usar una biblioteca PDF de .NET como IronPDF?

Usar una biblioteca PDF de .NET como IronPDF ofrece numerosos beneficios, incluyendo la capacidad de crear, editar y manipular PDFs a partir de varias entradas como HTML, CSS, imágenes y JavaScript. Soporta operaciones asíncronas y ayuda a mantener el diseño y los estilos originales del contenido web en los PDFs.

¿Cómo puede el patrón Factory mejorar la generación de documentos PDF?

El patrón Factory mejora la generación de documentos PDF permitiendo a los desarrolladores definir una interfaz común para crear PDFs a partir de diferentes fuentes, como cadenas HTML, URLs o archivos. Esto permite agregar nuevos tipos de PDF sin alterar el código existente, adhiriéndose al Principio de apertura/cierre.

¿En qué escenarios es más útil el patrón Factory?

El patrón Factory es más útil en escenarios donde un sistema necesita manejar la creación de objetos de manera dinámica, basada en la entrada del usuario o la configuración. Es particularmente beneficioso en aplicaciones que requieren cambios o extensiones frecuentes en el proceso de creación de objetos.

¿Cuál es la importancia del patrón Factory en el mantenimiento de la flexibilidad del software?

La importancia del patrón Factory en el mantenimiento de la flexibilidad del software radica en su capacidad para separar la creación de objetos de la lógica de negocio. Esto permite a los desarrolladores introducir nuevos tipos de objetos sin modificar el código existente, manteniendo así una arquitectura flexible y extensible.

¿Cómo soporta IronPDF el patrón Factory en la creación de documentos?

IronPDF soporta el patrón Factory en la creación de documentos permitiendo a los desarrolladores implementar el patrón a través de sus interfaces y métodos. Por ejemplo, usando ChromePdfRenderer con diferentes tipos de entrada, los desarrolladores pueden crear varias formas de documentos PDF sin alterar la lógica de creación subyacente.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita