Não encontrou o que procurava?
Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. Migração do DinktoPDF para o IronPDF
GUIAS DE MIGRAçãO

Como migrar do DinkToPdf para o IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

ODinkToPdfutiliza o wkhtmltopdf como base, herdando todas as suas vulnerabilidades de segurança e limitações técnicas. Compreender essas questões é fundamental para avaliar a urgência da migração.

Questões críticas de segurança

DinkToPdf herda avisos de segurança não corrigidos do wkhtmltopdf:

  1. CVE-2022-35583 (SSRF): Um conselho de Server-Side Request Forgery contra wkhtmltopdf 0.12.6 (CVSS 9.8 em NVD; disputado pelo projeto upstream como uma questão de sanitização de entrada do lado do aplicativo em vez de um bug da biblioteca). De qualquer forma, isso não será corrigido.
  2. Projeto Arquivado: O repositório wkhtmltopdf/wkhtmltopdf foi arquivado em 2 de janeiro de 2023, e toda a organização wkhtmltopdf no GitHub foi arquivada em 10 de julho de 2024.
  3. Sem Futuras Correções de Segurança: Quaisquer vulnerabilidades conhecidas ou futuras não serão corrigidas no upstream.

Problemas técnicos

Emitir Impacto
Segurança da rosca BasicConverter é apenas single-threaded; SynchronizedConverter serializa chamadas e ainda pode causar falhas no lado nativo sob carga
Binários nativos Implantação complexa com binários libwkhtmltox específicos para a plataforma
Limitações do CSS Fork mais antigo do QtWebKit — sem suporte moderno aFlexbox/Gridlayout
JavaScript Execução inconsistente, tempos limite excedidos
Renderização Mecanismo desatualizado baseado em QtWebKit (wkhtmltopdf 0.12.6, último lançamento em junho de 2020)
Manutenção DinkToPdf1.0.8 último lançamento em 18 de abril de 2017 no NuGet

Comparação de arquitetura

Aspecto DinkToPdf IronPDF
Segurança CVE-2022-35583 (SSRF), não corrigido / contestado no upstream Nenhum CVE crítico conhecido
Motor de renderização Fork mais antigo do QtWebKit (wkhtmltopdf 0.12.6) Cromo moderno
Segurança da rosca SynchronizedConverter serializa chamadas; native-side crashes reported under load Projetado para ser seguro contra roscas.
Dependências nativas Binários libwkhtmltox específicos para a plataforma Pacote NuGet gerenciado
Suporte a CSS NenhumFlexbox/Gridmoderno CSS3completo
JavaScript Limitado, inconsistente Apoiado
Manutenção Último lançamento doDinkToPdfem abril de 2017; organização wkhtmltopdf arquivada em julho de 2024 Mantido ativamente

Comparação de recursos

Recurso DinkToPdf IronPDF
HTML para PDF ✅(motor desatualizado) ✅(Cromo)
URL para PDF ✅ ✅
Margens personalizadas ✅ ✅
Cabeçalhos/Rodapés ✅(limitado) ✅(HTML completo)
CSS3 ❌Quantidade limitada ✅Completo
Flexbox/Grid ❌ ✅
JavaScript ⚠ Limitado ✅Completo
Manipulação de PDF ❌ ✅
Preenchimento de formulário ❌ ✅
Assinaturas digitais ❌ ✅
Criptografia ❌ ✅
Marcas d'água ❌ ✅
Mesclar/Dividir ❌ ✅

Preparação pré-migratória

Pré-requisitos

Certifique-se de que seu ambiente atenda a estes requisitos:

  • .NET Framework 4.6.2+, .NET Core 3.1+, or .NET 5/6/7/8/9/10
  • Visual Studio 2019 ou superior ou VS Code com extensão C#
  • Acesso ao Gerenciador de Pacotes NuGet
  • Chave de licença do IronPDF(teste gratuito disponível em IronPDF )

Auditoria de uso do DinkToPdf

Execute estes comandos no diretório da sua solução para identificar todas as referências a DinkToPdf:

# Find allDinkToPdfusages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
# Find allDinkToPdfusages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
SHELL

Mudanças significativas a serem previstas

Mudar DinkToPdf IronPDF Impacto
Conversor SynchronizedConverter(new PdfTools()) ChromePdfRenderer Instanciação mais simples
Documento HtmlToPdfDocument Chamada de método direta Nenhum objeto de documento
Configurações GlobalSettings + ObjectSettings RenderingOptions Objeto de opções único
Tipo de retorno byte[] PdfDocument Objeto mais poderoso
Binário libwkhtmltox.dll/so Nenhum (gerenciado) Remover arquivos nativos
Segurança da rosca BasicConverter single-threaded; SynchronizedConverter serializa Seguro para threads por padrão Código mais simples
DI Singleton necessário Qualquer vida Flexível

Processo de migração passo a passo

Passo 1: Atualizar pacotes NuGet

Remova oDinkToPdfe instale o IronPDF:

# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
SHELL

Etapa 2: Remover binários nativos

Exclua estes arquivos específicos da plataforma do seu projeto:

  • libwkhtmltox.dll (Windows)
  • libwkhtmltox.so (Linux)
  • libwkhtmltox.dylib (macOS)

O IronPDF não possui dependências nativas — tudo é código gerenciado.

Etapa 3: Atualizar referências de namespace

Substitua os namespaces doDinkToPdfpelo IronPDF:

// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Etapa 4: Configurar a licença

// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Referência completa para migração de API

Mapeamento de Classes Principais

DinkToPdf IronPDF
SynchronizedConverter ChromePdfRenderer
BasicConverter ChromePdfRenderer
PdfTools Não é necessário
HtmlToPdfDocument Não é necessário
GlobalSettings RenderingOptions
ObjectSettings RenderingOptions
MarginSettings Propriedades de margem individuais

Mapeamento de configurações globais

DinkToPdfConfiguraçõesGlobais Equivalente ao IronPDF
ColorMode = ColorMode.Color Padrão (sempre colorido)
Orientation = Orientation.Portrait PaperOrientation = PdfPaperOrientation.Portrait
Orientation = Orientation.Landscape PaperOrientation = PdfPaperOrientation.Landscape
PaperSize = PaperKind.A4 PaperSize = PdfPaperSize.A4
Margins = new MarginSettings() Propriedades de margem individuais

Mapeamento de configurações de margem

Margens doDinkToPdf Equivalente ao IronPDF
Margins.Top = 10 MarginTop = 10
Margins.Bottom = 10 MarginBottom = 10
Margins.Left = 15 MarginLeft = 15
Margins.Right = 15 MarginRight = 15

Exemplos de migração de código

HTML básico para PDF

A conversão fundamental demonstra a simplificação drástica da configuração complexa doDinkToPdfpara a API simplificada do IronPDF.

Implementação do DinkToPdf:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())
        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

O IronPDF reduz uma configuraçãoDinkToPdfde 20 linhas para 4 linhas. Sem SynchronizedConverter, sem PdfTools, sem HtmlToPdfDocument, sem ObjectSettings—apenas renderize e salve. Para mais opções, consulte a documentação de conversão de HTML para PDF .

Conversão de URL para PDF

Implementação do DinkToPdf:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    Page = "https://www.example.com",
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    Page = "https://www.example.com",
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())
        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = New List(Of ObjectSettings) From {
                New ObjectSettings() With {
                    .Page = "https://www.example.com"
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

RenderUrlAsPdf do IronPDF substitui a configuração aninhada ObjectSettings.Page por uma chamada de método direta. Para mais opções, consulte o link para a documentação em PDF .

Configurações personalizadas com orientação paisagem e margens

Implementação do DinkToPdf:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.pdf", pdf);
    }
}
// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.pdf", pdf);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())
        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.A4,
                .Margins = New MarginSettings() With {
                    .Top = 10,
                    .Bottom = 10,
                    .Left = 15,
                    .Right = 15
                }
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("custom.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 15
        renderer.RenderingOptions.MarginRight = 15

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

RenderingOptions do IronPDF substitui tanto GlobalSettings quanto MarginSettings por uma API unificada e fluente. Para obter mais opções de configuração, consulte a documentação de opções de renderização .

Notas críticas sobre migração

Remover binários nativos

A etapa de limpeza mais importante é a remoção dos binários nativos do wkhtmltopdf.IronPDF não possui dependências nativas:

# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
SHELL

Não é necessário nenhum singleton.

A orientação documentada doDinkToPdfé registrar SynchronizedConverter como um singleton. ChromePdfRenderer do IronPDF é seguro para threads com qualquer tempo de vida DI:

//DinkToPdf- typically registered as singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
//DinkToPdf- typically registered as singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
' DinkToPdf - typically registered as singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' IronPDF - any lifetime works
services.AddScoped(Of ChromePdfRenderer)()
' Or just create inline:
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Tipo de retorno mais rico

DinkToPdf retorna byte[].IronPDF retorna PdfDocument com capacidades de manipulação:

//DinkToPdfreturns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
//DinkToPdfreturns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
' DinkToPdf returns byte()
Dim pdf As Byte() = converter.Convert(doc)
File.WriteAllBytes("output.pdf", pdf)
Return File(pdf, "application/pdf")

' IronPDF returns PdfDocument
Dim pdfDoc = renderer.RenderHtmlAsPdf(html)
pdfDoc.SaveAs("output.pdf")
Return File(pdfDoc.BinaryData, "application/pdf")
$vbLabelText   $csharpLabel

Suporte completo a CSS3

Os layouts modernos que não funcionam noDinkToPdffuncionam perfeitamente no IronPDF:

//DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
//DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
' DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
Dim html As String = "<div style='display: flex;'>...</div>"  ' Broken!

' IronPDF- full support (modern Chromium)
Dim html As String = "
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)  ' Works!
$vbLabelText   $csharpLabel

Lista de verificação pós-migração

Após concluir a migração do código, verifique o seguinte:

  • Execute todos os testes unitários para verificar se a geração de PDF funciona corretamente.
  • Teste cenários multi-threading (o caminho SynchronizedConverter serializa chamadas e era propenso a falhas no lado nativo sob carga)
  • Compare a qualidade de saída do PDF (o Chromium do IronPDF oferece melhor renderização)
  • Verificar renderização CSS (Flexbox/Grid agora funciona)
  • Teste a execução doJavaScript(confiável com o IronPDF)
  • Atualizar os pipelines de CI/CD para remover a instalação do wkhtmltopdf
  • Verificar se a verificação de segurança foi aprovada (sem mais sinalizadores CVE-2022-35583)
  • Remover a implantação de binários nativos dos scripts Docker/deployment

Recursos adicionais

Migrar deDinkToPdfpara IronPDF aposenta a superfície de ataque não corrigida do wkhtmltopdf (CVE-2022-35583), o modelo de concorrência serializado SynchronizedConverter, a implantação de binário nativo e o caminho de renderização QtWebKit mais antigo. A transição para um motor Chromium moderno fornece suporte completo ao CSS3, execução confiável deJavaScripte uma biblioteca mantida ativamente.

ObserveDinkToPdf e wkhtmltopdf são marcas registradas de seus respectivos proprietários. Este site não é afiliado, endossado ou patrocinado porDinkToPdfou wkhtmltopdf. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.

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. Comece seu teste gratuito

Equipe de Suporte Iron

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