Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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.
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.
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.
public interface IVehicle
{
void DisplayInfo();
}
public interface IVehicle
{
void DisplayInfo();
}
Public Interface IVehicle
Sub DisplayInfo()
End Interface
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
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
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
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
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.
El patrón de fábrica ofrece varias ventajas, especialmente en sistemas complejos:
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 HTMLCSS, 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.
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.
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
Aquí definimos dos implementaciones concretas de IPdfCreator: una para crear PDFs a partir de cadenas HTML y otra a partir de 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
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://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
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.
Las siguientes capturas de pantalla son el resultado del código:
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.
9 productos API .NET para sus documentos de oficina