Factory Pattern C# (Cómo funciona para desarrolladores)

En Patrón de fábrica en C# es un enfoque estructural que pertenece a la categoría de patrones de diseño. El patrón de diseño del método Factory en C# está orientado a resolver problemas relacionados con la creación de objetos sin especificar la clase creadora exacta del objeto que se creará.

Esencialmente, el patrón fábrica se ocupa de la creación de objetos delegándola a una clase específica, conocida como clase fábrica. Esto permite que un sistema sea más flexible y fácil de gestionar, especialmente cuando se introducen nuevos tipos de objetos, ya que la clase fábrica se encarga del proceso de creación de objetos, reduciendo la dependencia de las clases concretas. Vamos a sumergirnos en cómo se puede implementar y utilizar el patrón de método de fábrica, un patrón de diseño de creación en C#. Exploraremos la Biblioteca IronPDF más tarde.

Estructura básica del patrón del método de fábrica

La idea central detrás del patrón de métodos de fábrica es definir una interfaz común para la creación de objetos al tiempo que permite a las subclases cambiar el tipo de objetos que crean. Este patrón incluye algunos componentes clave: patrón de fábrica abstracto, patrones de diseño de creación, patrón de diseño de fábrica, código existente, patrón de fábrica básico, patrones de fábrica abstractos, ejemplos del mundo real, producto concreto, objetos relacionados o dependientes y clase concreta.

• Interfaz de producto: Especifica la estructura de los objetos creados por el método de fábrica.
• Clases de productos concretos: Implementan la interfaz del producto.
• Clase Creador (Creador de clases abstractas): Declara el método factory, que devuelve un objeto de la interfaz product.
• Creador de hormigón: Modifica el método de fábrica para entregar una instancia del producto concreto.

Ejemplo: Fábrica de vehículos

Imaginemos que tenemos distintos tipos de vehículos, como coches y camiones. Usaremos el patrón de fábrica para crear una fábrica de vehículos que pueda crear diferentes tipos de vehículos basados en la entrada del usuario o en un archivo de configuración.

Paso 1: Definir la interfaz del producto

public interface IVehicle
{
    void DisplayInfo();
}

public interface IVehicle
{
    void DisplayInfo();
}

Public Interface IVehicle
	Sub DisplayInfo()
End Interface

Paso 2: Aplicar productos concretos

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

Paso 3: Crear la clase creadora abstracta

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

Paso 4: Implantar el Creador de Hormigón

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

Paso 5: Uso del código cliente

class Program
{
    static void Main(string [] args)
    {
        //  crear objetos
        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)
    {
        //  crear objetos
        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)
		'  crear objetos
		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

En el ejemplo anterior, la clase VehicleFactory sirve como creador abstracto, siendo la clase ConcreteVehicleFactory el creador concreto que implementa el método de fábrica CreateVehicle. Este método decide qué tipo de vehículo crear en función de la información que recibe. A continuación, el código del cliente utiliza la fábrica para crear instancias de distintos vehículos, lo que favorece el acoplamiento flexible entre la lógica de creación de objetos y el código del cliente.

Ventajas de utilizar el patrón de fábrica

El patrón de fábrica ofrece varias ventajas, especialmente en sistemas complejos:

• Acoplamiento flexible: El código del cliente interactúa con interfaces o clases abstractas en lugar de clases concretas del producto. El resultado es un diseño más flexible y fácil de modificar.
• Software reutilizable orientado a objetos: El patrón de fábrica promueve la reutilización de código ya que separa la lógica de creación de objetos del sistema, haciendo que el sistema sea más fácil de mantener y extender.
• Flexibilidad en la creación de objetos: El método de fábrica permite diferentes implementaciones para la creación de objetos, que pueden ser seleccionadas en tiempo de ejecución. Esto es especialmente útil en escenarios en los que el tipo de objetos requeridos puede variar en función de factores externos.

IronPDF: Solución PDF .NET

IronPDF es una biblioteca diseñada para la plataforma .NET, que ayuda a los desarrolladores a crear, editar y manipular fácilmente Archivos PDF directamente desde HTML CSS, imágenes y JavaScript, sin tener que sumergirse en complejas API de generación de PDF. Su principal atractivo reside en su capacidad para transformar contenidos web en documentos PDF de forma rápida y con gran precisión, gracias al uso de un motor de renderizado basado en Chrome.

Entre sus principales características se incluyen la generación de PDF a partir de cadenas HTML o URL, la renderización de páginas web como PDF sobre la marcha y la posibilidad de trabajar con aplicaciones de formularios, aplicaciones de servidor e intranets seguras, entre otras. Su rendimiento está optimizado para la eficiencia, con capacidades para operaciones asíncronas, registro personalizado y amplia documentación para ayudarle a empezar rápidamente.

Ejemplo de código

Para ilustrar cómo IronPDF puede integrarse con el Factory Pattern, vamos a crear un ejemplo simplificado. El patrón Factory es un tipo de patrón de diseño de creación que ofrece una forma de crear productos u objetos concretos dentro de una superclase, permitiendo a las subclases modificar los objetos específicos que se producen. Esto se adapta bien a la creación de distintos tipos de documentos PDF en función de necesidades específicas, como a partir de cadenas HTML, URL o archivos.

Crearemos una interfaz llamada IPdfCreator que define un método para crear PDFs, y luego implementaremos diferentes clases de fábrica que crean PDFs de varias maneras usando IronPDF.

Paso 1: Definir la interfaz IPdfCreator

Esta interfaz declara el método CreatePdf que implementarán todas las fábricas concretas.

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

Paso 2: Implantar fábricas de hormigón

Aquí definimos dos implementaciones concretas de IPdfCreator: una para crear PDFs a partir de cadenas HTML y otra a partir de URLs.

//  clase pública
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");
    }
}

//  clase pública
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");
    }
}

'  clase pública
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

Paso 3: Utilizar la fábrica

En su aplicación, ahora puede utilizar estas fábricas para crear documentos PDF a partir de diferentes fuentes sin preocuparse de los detalles del proceso de creación de 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://ejemplo.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://ejemplo.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://ejemplo.com")
	End Sub
End Class

En esta configuración, HtmlStringPdfCreator y UrlPdfCreator son fábricas concretas que producen PDFs. La clase Program, actuando como cliente, utiliza estas fábricas sin necesidad de conocer los intrincados detalles de cómo se generan los PDF a partir de cadenas HTML o URL. Este enfoque proporciona flexibilidad, ya que puede introducir nuevas formas de crear PDF (por ejemplo, a partir de archivos o flujos) simplemente añadiendo más fábricas que implementen la interfaz IPdfCreator, siguiendo el Principio Abierto/Cerrado del diseño orientado a objetos.

Salida

Las siguientes capturas de pantalla son el resultado del código:

Conclusión

El patrón de fábrica en C# proporciona un marco para gestionar la creación de objetos, haciendo que el diseño de software sea más mantenible y extensible. Al utilizar clases concretas para implementar una fábrica abstracta y una lógica de creación de delegados, los desarrolladores pueden crear sistemas más fáciles de adaptar y ampliar. Tanto si se trata de unas pocas clases como de un sistema con dependencias complejas, el patrón de fábrica ofrece un enfoque estructurado para la creación exacta de objetos de clase. Resulta especialmente beneficioso en situaciones en las que el tipo de objetos que deben crearse puede variar en función de la entrada del usuario, la configuración o el estado de la aplicación.

IronPDF ofrece un prueba gratuita para empezar, y las opciones de licencia empiezan en 749 dólares, dirigidas a desarrolladores que buscan integrar funcionalidades PDF en sus aplicaciones .NET.