Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. Migración de Fluid a IronPDF
GUíAS DE MIGRACIóN

Migración de Fluid (Templating) a IronPDF

Curtis Chau
Curtis Chau
Actualizado:

Fluid es una biblioteca .NET que implementa el lenguaje de plantillas Liquid, ofreciendo a los desarrolladores una forma flexible de renderizar plantillas dinámicas y separar el contenido de la lógica de presentación. Si bien Fluid es eficaz para generar salidas de texto dinámicas, no admite directamente la generación de PDF: los desarrolladores deben integrar una biblioteca PDF adicional para convertir la salida HTML en documentos PDF. Este enfoque de dos bibliotecas introduce una complejidad que muchos equipos de desarrollo tratan de eliminar.

Esta guía proporciona una ruta de migración completa de Fluid (plantillas) con bibliotecas PDF externas a IronPDF, con instrucciones paso a paso, comparaciones de código y ejemplos prácticos para desarrolladores .NET profesionales que evalúan esta transición.

Por qué migrar de Fluid (Templating) a IronPDF

Fluid es un motor de plantillas sólido basado en Liquid, pero su uso para la generación de PDF introduce una complejidad significativa:

Dependencia de dos bibliotecas: Fluid solo genera HTML; necesita una biblioteca PDF separada (wkhtmltopdf, PuppeteerSharp, etc.) para crear archivos PDF, lo que duplica sus dependencias y la carga de mantenimiento.

Complejidad de integración: coordinar dos bibliotecas significa administrar dos conjuntos de configuraciones, manejo de errores y actualizaciones. Cuando algo se rompe, la depuración se convierte en todo un reto.

Curva de aprendizaje de sintaxis líquida: los desarrolladores deben aprender la sintaxis de plantillas de Liquid ({{ }}, {% %}) cuando C# ya tiene incorporadas potentes capacidades de manejo de cadenas.

Control de PDF limitado: la calidad de salida de PDF depende de la biblioteca de PDF que elija para combinar con Fluid, no de un motor de renderizado dedicado.

Desafíos de depuración: pueden ocurrir errores tanto en la etapa de creación de plantillas como en la de generación de PDF, lo que hace que la resolución de problemas sea más difícil que con una única solución integrada.

Preocupaciones sobre la seguridad de los subprocesos: TemplateContext no es seguro para subprocesos y requiere una gestión cuidadosa en aplicaciones concurrentes.

IronPDF frente a Fluid (Templating): Comparación de características

Comprender las diferencias arquitectónicas ayuda a los responsables técnicos a evaluar la inversión en migración:

Aspecto Biblioteca Fluid + PDF IronPDF
Dependencias 2+ paquetes (Fluid + biblioteca PDF) Paquete único
Planificación Sintaxis líquida ({{ }}) Interpolación de cadenas en C# o Razor
Generación de PDF Biblioteca externa necesaria Motor Chromium integrado
Soporte CSS Depende de la biblioteca PDF CSS3 completo con Flexbox/Grid
JavaScript Depende de la biblioteca PDF Compatibilidad total con JavaScript
Seguridad de hilos TemplateContext no es thread-safe ChromePdfRenderer es a prueba de hilos
Curva de aprendizaje API de la biblioteca Liquid + PDF HTML/CSS (estándares web)
Manejo de errores Dos fuentes de error Fuente de error única

Inicio rápido: Migración de Fluid a IronPDF

La migración puede comenzar inmediatamente con estos pasos básicos.

Paso 1: Sustituir paquetes NuGet

Elimine Fluid y cualquier biblioteca PDF externa:

# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
# Remove Fluid and external PDF library
dotnet remove package Fluid.Core
dotnet remove package WkHtmlToPdf-DotNet  # or whatever PDF library you used
dotnet remove package PuppeteerSharp       # if used
SHELL

Instalar IronPDF:

# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
# InstallIronPDF(all-in-one solution)
dotnet add package IronPdf
SHELL

Paso 2: Actualizar los espacios de nombres

Sustituya los espacios de nombres Fluid por IronPDF:

// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
// Before (Fluid + external PDF library)
using Fluid;
using Fluid.Values;
using SomeExternalPdfLibrary;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
Imports Fluid
Imports Fluid.Values
Imports SomeExternalPdfLibrary

Imports IronPdf
Imports IronPdf.Rendering ' For RenderingOptions
$vbLabelText   $csharpLabel

Paso 3: Inicializar licencia

Añadir inicialización de licencia al inicio de la aplicación:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Ejemplos de migración de código

HTML básico a PDF

La operación más fundamental revela la diferencia clave entre estos enfoques.

Enfoque fluido:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>");
        var context = new TemplateContext();
        context.SetValue("name", "World");
        var html = await template.RenderAsync(context);

        // Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html);
    }
}
Imports Fluid
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("<html><body><h1>Hello {{name}}!</h1></body></html>")
        Dim context As New TemplateContext()
        context.SetValue("name", "World")
        Dim html = Await template.RenderAsync(context)

        ' Fluid only generates HTML - you'd need another library to convert to PDF
        File.WriteAllText("output.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World!</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World!</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Fluid requiere crear un FluidParser, analizar la cadena de plantilla, crear un TemplateContext, llamar a SetValue() para cada variable, renderizar de forma asincrónica para obtener HTML y luego escribir en un archivo, que todavía no es un PDF. El comentario en el código dice explícitamente "Fluid sólo genera HTML - necesitarías otra librería para convertir a PDF."

IronPDF elimina esta complejidad: crea un renderizador, llama a RenderHtmlAsPdf() y guarda directamente en PDF. Sin archivos HTML intermedios ni bibliotecas adicionales.

Para situaciones avanzadas de conversión de HTML a PDF, consulte la Guía de conversión de HTML a PDF.

Plantilla de factura con datos dinámicos

Las plantillas de documentos con múltiples variables muestran claramente las diferencias en el patrón de plantillas.

Enfoque fluido:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("invoiceNumber", "12345");
        context.SetValue("date", DateTime.Now.ToShortDateString());
        context.SetValue("customer", "John Doe");
        context.SetValue("total", 599.99);

        var html = await template.RenderAsync(context);
        // Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html);
    }
}
Imports Fluid
Imports System
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("
            <html><body>
                <h1>Invoice #{{invoiceNumber}}</h1>
                <p>Date: {{date}}</p>
                <p>Customer: {{customer}}</p>
                <p>Total: ${{total}}</p>
            </body></html>")

        Dim context As New TemplateContext()
        context.SetValue("invoiceNumber", "12345")
        context.SetValue("date", DateTime.Now.ToShortDateString())
        context.SetValue("customer", "John Doe")
        context.SetValue("total", 599.99)

        Dim html = Await template.RenderAsync(context)
        ' Fluid outputs HTML - requires additional PDF library
        File.WriteAllText("invoice.html", html)
    End Function
End Module
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var invoiceNumber = "12345";
        var date = DateTime.Now.ToShortDateString();
        var customer = "John Doe";
        var total = 599.99;

        var html = $@"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {date}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim invoiceNumber As String = "12345"
        Dim [date] As String = DateTime.Now.ToShortDateString()
        Dim customer As String = "John Doe"
        Dim total As Double = 599.99

        Dim html As String = $"
            <html><body>
                <h1>Invoice #{invoiceNumber}</h1>
                <p>Date: {[date]}</p>
                <p>Customer: {customer}</p>
                <p>Total: ${total}</p>
            </body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("invoice.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Fluid utiliza la sintaxis {{variable}} de Liquid con context.SetValue() para cada variable. El comentario indica explícitamente que "Fluid genera HTML; requiere una biblioteca PDF adicional".IronPDFutiliza la interpolación de cadenas estándar de C# ($"{variable}") —sintaxis que los desarrolladores ya conocen— y genera la salida directamente en PDF.

Explore los tutoriales IronPDF para conocer más patrones de generación de documentos.

Datos dinámicos con bucles

Las plantillas con colecciones y bucles demuestran las diferencias en el flujo de control.

Enfoque fluido:

// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
// NuGet: Install-Package Fluid.Core
using Fluid;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var parser = new FluidParser();
        var template = parser.Parse(@"
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>");

        var context = new TemplateContext();
        context.SetValue("title", "My List");
        context.SetValue("items", new[] { "Item 1", "Item 2", "Item 3" });

        var html = await template.RenderAsync(context);
        // Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html);
    }
}
Imports Fluid
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks

Class Program
    Shared Async Function Main() As Task
        Dim parser As New FluidParser()
        Dim template = parser.Parse("
            <html><body>
                <h1>{{title}}</h1>
                <ul>
                {% for item in items %}
                    <li>{{item}}</li>
                {% endfor %}
                </ul>
            </body></html>")

        Dim context As New TemplateContext()
        context.SetValue("title", "My List")
        context.SetValue("items", New String() {"Item 1", "Item 2", "Item 3"})

        Dim html = Await template.RenderAsync(context)
        ' Fluid generates HTML only - separate PDF conversion needed
        File.WriteAllText("template-output.html", html)
    End Function
End Class
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var title = "My List";
        var items = new[] { "Item 1", "Item 2", "Item 3" };

        var html = $@"
            <html><body>
                <h1>{title}</h1>
                <ul>";

        foreach (var item in items)
        {
            html += $"<li>{item}</li>";
        }

        html += "</ul></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("template-output.pdf");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim title As String = "My List"
        Dim items As String() = {"Item 1", "Item 2", "Item 3"}

        Dim html As String = $"
            <html><body>
                <h1>{title}</h1>
                <ul>"

        For Each item As String In items
            html += $"<li>{item}</li>"
        Next

        html += "</ul></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("template-output.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Fluid utiliza la sintaxis {% for item in items %}...{% endfor %} de Liquid, un lenguaje de plantillas que los desarrolladores deben aprender. El comentario indica: "Fluid solo genera HTML; se requiere una conversión a PDF por separado".IronPDFutiliza bucles estándar de C# (sin necesidad de aprender sintaxis nueva) y genera la salida directamente en PDF.

Referencia de mapeo de Fluid API a IronPDF

Este mapeo acelera la migración al mostrar los equivalentes directos de las API:

Mapeo de clases principales

Clase Fluid Equivalente de IronPDF
FluidParser N/A
FluidTemplate N/A
TemplateContext Objetos/cadenas de C#
TemplateOptions RenderingOptions
FluidValue Tipos nativos de C#
Clase de PDF externo ChromePdfRenderer

Métodos

Método Fluid Equivalente de IronPDF
new FluidParser() new ChromePdfRenderer()
parser.Parse(source) N/A
template.RenderAsync(context) renderer.RenderHtmlAsPdf(html)
context.SetValue("key", value) var key = value;

Mapeo de sintaxis líquida a C

Sintaxis líquida Equivalente de C#
{{ variable }} $"{variable}"
{% for item in items %} foreach (var item in items)
{% if condition %} if (condition)
{{ x \| mayúsculas }} x.ToUpper()
{{ x \| date: '%Y-%m-%d' }} x.ToString("yyyy-MM-dd")
{{ x \| número_con_precisión: 2 }} x.ToString("F2")

Problemas comunes de migración y soluciones

Número 1: Conversión de sintaxis líquida

Fluido: utiliza la sintaxis {{ variable }} y {% control %}.

Solución: Sustituir por interpolación de cadenas y flujo de control en C#:

// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
// Liquid: {{ name | upcase }}
// C#: $"{name.ToUpper()}"

// Liquid: {% for item in items %}{{item}}{% endfor %}
// C#: foreach (var item in items) { html += $"{item}"; }
$vbLabelText   $csharpLabel

Número 2: Variables TemplateContext

Fluido: utiliza context.SetValue("key", value) para pasar datos.

Solución: Utilizar variables estándar de C#:

// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
// Before (Fluid)
var context = new TemplateContext();
context.SetValue("customer", customerName);

// After (IronPDF)
var customer = customerName;
var html = $"<p>Customer: {customer}</p>";
' Before (Fluid)
Dim context As New TemplateContext()
context.SetValue("customer", customerName)

' After (IronPDF)
Dim customer = customerName
Dim html = $"<p>Customer: {customer}</p>"
$vbLabelText   $csharpLabel

Número 3: Seguridad de hilos

Fluid: TemplateContext no es seguro para subprocesos, por lo que requiere una gestión cuidadosa en aplicaciones concurrentes.

Solución: ChromePdfRenderer es seguro para subprocesos y se puede compartir entre subprocesos:

// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
// Thread-safe usage
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] GeneratePdf(string html)
{
    var pdf = _renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}
' Thread-safe usage
Private Shared ReadOnly _renderer As New ChromePdfRenderer()

Public Function GeneratePdf(html As String) As Byte()
    Dim pdf = _renderer.RenderHtmlAsPdf(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

Número 4: Tratamiento de errores en dos fases

Fluid: Pueden producirse errores en la fase de creación de plantillas O en la fase de generación de PDF.

Solución:IronPDFtiene una única fuente de error:

try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    // Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}
Try
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
Catch ex As Exception
    ' Single point of failure—easier debugging
    Console.WriteLine($"PDF generation failed: {ex.Message}")
End Try
$vbLabelText   $csharpLabel

Lista de comprobación de migración de fluidos

Tareas previas a la migración

Audite su código base para identificar todo el uso de Fluid:

# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
# Find all Fluid references
grep -r "FluidParser\|FluidTemplate\|TemplateContext\|using Fluid" --include="*.cs" --include="*.csproj" .

# Find Liquid template files
find . -name "*.liquid" -o -name "*.html" | xargs grep -l "{{"
SHELL

Documente todas las plantillas: ubicaciones de archivos, variables utilizadas, bucles y condicionales, y configuración de bibliotecas PDF externas.

Tareas de actualización de código

  1. Eliminar el paquete NuGet de Fluid.Core
  2. Eliminar el paquete de bibliotecas PDF externas
  3. Instalación del paquete IronPdf NuGet
  4. Actualizar las importaciones de espacios de nombres de Fluid a IronPdf
  5. Convertir {{ variable }} a $"{variable}"
  6. Convertir {% for item in collection %} a C# foreach
  7. Convertir {% if condition %} en declaraciones C# if
  8. Convierta los filtros de Liquid en métodos de C# (por ejemplo, | upcase → .ToUpper())
  9. Reemplace FluidParser con ChromePdfRenderer
  10. Reemplace TemplateContext.SetValue() con variables directas de C#
  11. Eliminar las llamadas a bibliotecas PDF externas
  12. Añadir la inicialización de la licenciaIronPDFal inicio

Pruebas posteriores a la migración

Tras la migración, verifique estos aspectos:

  • Verificación de que el resultado PDF se ajusta a las expectativas
  • Pruebe que todas las variaciones de la plantilla se muestran correctamente
  • Compruebe que las imágenes y el estilo se muestran correctamente
  • Validar que los saltos de página se produzcan correctamente
  • Prueba con varios tamaños de datos
  • Pruebas de rendimiento frente a Fluid + biblioteca externa
  • Pruebe la seguridad de los subprocesos en escenarios concurrentes

Tareas de limpieza

  • Eliminar los archivos de plantilla .liquid (si ya no son necesarios)
  • Eliminar el código de ayuda relacionado con Fluid
  • Actualización de la documentación
  • Limpiar dependencias no utilizadas

Beneficios clave de migrar a IronPDF

Pasar de Fluid (creación de plantillas) con bibliotecas PDF externas aIronPDFofrece varias ventajas fundamentales:

Solución de paquete único: eliminar la dependencia de dos bibliotecas.IronPDFse encarga tanto de la creación de plantillas (mediante HTML/CSS) como de la generación de PDF en un solo paquete.

No hay ninguna sintaxis nueva que aprender: utilice la interpolación de cadenas y el flujo de control de C# estándar en lugar de aprender la sintaxis de plantillas de Liquid.

Representación segura para subprocesos: ChromePdfRenderer es segura para subprocesos, a diferencia de TemplateContext, lo que simplifica la generación simultánea de PDF.

Motor de renderizado Chromium: la renderización estándar de la industria garantiza compatibilidad total con CSS3, incluidos Flexbox y Grid, además de ejecución completa de JavaScript .

Fuente de error única: la depuración se vuelve más sencilla con una sola biblioteca para solucionar problemas en lugar de coordinar entre las etapas de creación de plantillas y generación de PDF.

Desarrollo activo: a medida que aumenta la adopción de .NET 10 y C# 14 hasta 2026, las actualizaciones periódicas deIronPDFgarantizan la compatibilidad con las versiones actuales y futuras de .NET .

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. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame