Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. Migração de Fluid para IronPDF
GUIAS DE MIGRAçãO

Migrando do Fluid (Templates) para o IronPDF

Curtis Chau
Curtis Chau
Atualizado:

Fluid é uma biblioteca .NET que implementa a linguagem de modelagem Liquid, oferecendo aos desenvolvedores uma maneira flexível de renderizar modelos dinâmicos e separar o conteúdo da lógica de apresentação. Embora o Fluid seja eficaz na geração de saídas de texto dinâmicas, ele não oferece suporte direto à geração de PDFs — os desenvolvedores precisam integrar uma biblioteca de PDF adicional para converter a saída HTML em documentos PDF. Essa abordagem com duas bibliotecas introduz uma complexidade que muitas equipes de desenvolvimento buscam eliminar.

Este guia fornece um caminho de migração completo do Fluid (modelagem) com bibliotecas PDF externas para o IronPDF, com instruções passo a passo, comparações de código e exemplos práticos para desenvolvedores .NET profissionais que estejam avaliando essa transição.

Por que migrar do Fluid (modelagem) para o IronPDF?

Fluid é um mecanismo de modelagem baseado em Liquid sólido, mas usá-lo para geração de PDFs introduz uma complexidade significativa:

Dependência de duas bibliotecas: o Fluid gera apenas HTML — você precisa de uma biblioteca PDF separada (wkhtmltopdf, PuppeteerSharp, etc.) para criar PDFs, o que dobra suas dependências e o trabalho de manutenção.

Complexidade de integração: coordenar duas bibliotecas significa gerenciar dois conjuntos de configurações, tratamento de erros e atualizações. Quando algo dá errado, a depuração se torna mais desafiadora.

Curva de aprendizado da sintaxe Liquid: Os desenvolvedores precisam aprender a sintaxe de templates Liquid ({{ }}, {% %}) mesmo quando o C# já possui recursos avançados de manipulação de strings integrados.

Controle limitado sobre PDFs: a qualidade do seu PDF de saída depende da biblioteca de PDF que você escolher para usar com o Fluid, e não de um mecanismo de renderização dedicado.

Desafios de depuração: Os erros podem ocorrer tanto na fase de criação de modelos quanto na geração de PDFs, dificultando a resolução de problemas em comparação com uma solução integrada única.

Preocupações com a segurança de threads: TemplateContext não é seguro para threads e requer gerenciamento cuidadoso em aplicações concorrentes.

IronPDF vs Fluid (Templates): Comparação de Recursos

Compreender as diferenças arquitetônicas ajuda os responsáveis ​​pelas decisões técnicas a avaliar o investimento em migração:

Aspecto Fluido + Biblioteca PDF IronPDF
Dependências 2+ pacotes (Fluid + biblioteca PDF) Pacote único
Modelagem Sintaxe líquida ({{ }}) Interpolação de strings em C# ou Razor
Geração de PDF Biblioteca externa necessária Motor Chromium integrado
Suporte a CSS Depende da biblioteca de PDF. CSS3 completo com Flexbox/Grid
JavaScript Depende da biblioteca de PDF. Suporte completo a JavaScript
Segurança da rosca TemplateContext não é thread-safe ChromePdfRenderer é seguro para uso em múltiplas threads.
Curva de Aprendizagem API da biblioteca Liquid + PDF HTML/CSS (padrões da web)
Tratamento de erros Duas fontes de erro Fonte de erro única

Guia rápido: Migração do Fluid para o IronPDF

A migração pode começar imediatamente com esses passos fundamentais.

Passo 1: Substituir pacotes NuGet

Remova o Fluid e qualquer 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

Instale o IronPDF:

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

Etapa 2: Atualizar Namespaces

Substitua os namespaces do 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

Etapa 3: Inicializar a licença

Adicionar inicialização de licença na inicialização do aplicativo:

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

Exemplos de migração de código

HTML básico para PDF

A operação mais fundamental revela a principal diferença entre essas abordagens.

Abordagem fluida:

// 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

Abordagem 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 requer a criação de um FluidParser, a análise da string do modelo, a criação de um TemplateContext, a chamada de SetValue() para cada variável, a renderização assíncrona para obter HTML e, em seguida, a gravação em um arquivo — que ainda não é um PDF. O comentário no código afirma explicitamente: "O Fluid gera apenas HTML; você precisaria de outra biblioteca para converter para PDF."

O IronPDF elimina essa complexidade: crie um renderizador, chame RenderHtmlAsPdf() e salve diretamente em PDF. Sem arquivos HTML intermediários, sem bibliotecas adicionais.

Para cenários avançados de conversão de HTML para PDF, consulte o guia de conversão de HTML para PDF .

Modelo de fatura com dados dinâmicos

Os modelos de documentos com múltiplas variáveis ​​mostram claramente as diferenças nos padrões de modelagem.

Abordagem fluida:

// 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

Abordagem 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 usa a sintaxe {{variable}} do Liquid com context.SetValue() para cada variável. O comentário observa explicitamente que "Fluid gera HTML - requer uma biblioteca PDF adicional". O IronPDF usa interpolação de strings padrão do C# ($"{variable}") — sintaxe já conhecida pelos desenvolvedores — e gera saída diretamente em PDF.

Explore os tutoriais do IronPDF para conhecer mais padrões de geração de documentos.

Dados dinâmicos com loops

Os modelos com coleções e loops demonstram diferenças no fluxo de controle.

Abordagem fluida:

// 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

Abordagem 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 usa a sintaxe {% for item in items %}...{% endfor %} do Liquid — uma linguagem de modelagem que os desenvolvedores precisam aprender. O comentário observa: "O Fluid gera apenas HTML - é necessária uma conversão separada para PDF." O IronPDF usa loops padrão do C# — sem necessidade de aprender nova sintaxe — e gera saída diretamente em PDF.

Referência de mapeamento da API Fluid para o IronPDF

Este mapeamento acelera a migração ao mostrar equivalentes diretos da API:

Mapeamento de Classes Principais

Classe Fluida Equivalente ao IronPDF
FluidParser N / D
FluidTemplate N / D
TemplateContext Objetos/strings em C#
TemplateOptions RenderingOptions
FluidValue Tipos nativos de C#
Classe PDF externa ChromePdfRenderer

Mapeamento de Métodos

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

Mapeamento da sintaxe Liquid para C

Sintaxe líquida Equivalente em C#
{{ variable }} $"{variable}"
{% for item in items %} foreach (var item in items)
{% if condition %} if (condition)
{{ x \| upcase }} x.ToUpper()
{{ x \| data: '%Y-%m-%d' }} x.ToString("yyyy-MM-dd")
{{ x \| número_com_precisão: 2 }} x.ToString("F2")

Problemas e soluções comuns em migrações

Problema 1: Conversão de sintaxe Liquid

Fluid: Usa a sintaxe {{ variable }} e {% control %}.

Solução: Substitua por interpolação de strings e controle de fluxo em 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

Problema 2: Variáveis ​​de contexto de modelo

Fluid: Usa context.SetValue("key", value) para passar dados.

Solução: Utilize variáveis ​​padrão do 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

Questão 3: Segurança da rosca

Fluid: TemplateContext não é thread-safe, exigindo gerenciamento cuidadoso em aplicações concorrentes.

Solução: ChromePdfRenderer é thread-safe e pode ser compartilhado entre threads:

// 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

Problema 4: Tratamento de erros em dois estágios

Fluid: Podem ocorrer erros na fase de criação do modelo OU na fase de geração do PDF.

Solução: O IronPDF possui uma única origem de erro:

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 verificação para migração de fluidos

Tarefas pré-migração

Faça uma auditoria em sua base de código para identificar todo o uso do 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 todos os modelos: localização dos arquivos, variáveis ​​utilizadas, loops e condicionais, e configuração da biblioteca PDF externa.

Tarefas de atualização de código

  1. Remova o pacote NuGet Fluid.Core.
  2. Remover pacote de biblioteca PDF externa
  3. Instale o pacote NuGet IronPDF
  4. Atualize as importações de namespace de Fluid para IronPdf
  5. Converter {{ variable }} para $"{variable}"
  6. Converter {% for item in collection %} para C# foreach
  7. Converter {% if condition %} em instruções C# if
  8. Converter filtros Liquid em métodos C# (por exemplo, | upcase → .ToUpper())
  9. Substitua FluidParser por ChromePdfRenderer
  10. Substitua TemplateContext.SetValue() por variáveis ​​C# diretas.
  11. Remover chamadas de biblioteca PDF externas
  12. Adicionar inicialização da licença do IronPDF na inicialização do sistema.

Testes pós-migração

Após a migração, verifique os seguintes aspectos:

  • Verificar se o PDF gerado corresponde às expectativas.
  • Teste se todas as variações do modelo são renderizadas corretamente.
  • Verifique se as imagens e o estilo estão sendo exibidos corretamente.
  • Verificar se as quebras de página ocorrem corretamente.
  • Teste com vários tamanhos de dados
  • Teste de desempenho vs. Fluid + biblioteca externa
  • Testar a segurança de threads em cenários de concorrência

Tarefas de limpeza

  • Exclua os arquivos de modelo .liquid (se não forem mais necessários)
  • Remover código auxiliar relacionado a fluidos
  • Atualizar documentação
  • Limpar dependências não utilizadas

Principais benefícios da migração para o IronPDF

A migração do Fluid (modelagem com bibliotecas PDF externas) para o IronPDF oferece diversas vantagens cruciais:

Solução de pacote único: Elimine a dependência de duas bibliotecas. O IronPDF lida tanto com a criação de modelos (via HTML/CSS) quanto com a geração de PDFs em um único pacote.

Sem necessidade de aprender nova sintaxe: utilize a interpolação de strings e o fluxo de controle padrão do C# em vez de aprender a sintaxe de templates Liquid.

Renderização segura para threads: ChromePdfRenderer é seguro para threads, ao contrário de TemplateContext, simplificando a geração simultânea de PDFs.

Mecanismo de renderização Chromium: A renderização padrão do setor garante suporte completo ao CSS3, incluindo Flexbox e Grid, além da execução completa de JavaScript .

Fonte única de erro: a depuração torna-se mais simples com apenas uma biblioteca para solucionar problemas, em vez de coordenar as etapas de criação de modelos e geração de PDFs.

Desenvolvimento ativo: À medida que a adoção do .NET 10 e do C# 14 aumenta até 2026, as atualizações regulares do IronPDF garantem a compatibilidade com as versões atuais e futuras do .NET .

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim