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

Migrando de Haukcode.DinkToPdf para IronPDF

Curtis Chau
Curtis Chau
Atualizado:

Haukcode.DinkToPdf é uma continuação da biblioteca DinkToPdf, que já foi muito popular e usa o binário wkhtmltopdf para converter HTML em PDF para aplicações .NET . Embora o Haukcode.DinkToPdf tenha acompanhado as atualizações do .NET Core após o projeto original ter sido interrompido, ele apresenta problemas de segurança significativos devido à sua dependência original. O projeto wkhtmltopdf foi arquivado em janeiro de 2023, portanto esses problemas nunca serão resolvidos.

Este guia oferece um caminho de migração completo do Haukcode.DinkToPdf para o IronPDF, incluindo instruções passo a passo, comparações de código e exemplos práticos para desenvolvedores .NET profissionais que desejam eliminar os riscos de segurança de seus fluxos de trabalho de geração de PDFs.

Aviso de segurança crítico: CVE-2022-35583

Haukcode.DinkToPdf herda uma grave vulnerabilidade de segurança do wkhtmltopdf que não pode ser corrigida:

CVE-2022-35583 - Vulnerabilidade SSRF crítica (CVSS 9.8)

A biblioteca wkhtmltopdf (e todos os seus wrappers, incluindo Haukcode.DinkToPdf) é vulnerável a ataques de falsificação de requisição do lado do servidor (SSRF):

  • Vetor de ataque: Conteúdo HTML malicioso pode fazer com que o servidor busque recursos internos.
  • Ataque a metadados da AWS: É possível acessar http://169.254.169.254 para roubar credenciais da AWS.
  • Acesso à rede interna: Permite digitalizar e acessar serviços internos.
  • Inclusão de Arquivos Locais: Permite a leitura de arquivos locais através do protocolo file://
  • Impacto: Possibilidade de completa assunção da infraestrutura

Não há correção para essa vulnerabilidade porque o wkhtmltopdf foi abandonado e arquivado em 2023. A última versão lançada foi a 0.12.6, em 2020.

IronPDF vs Haukcode.DinkToPdf: 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 Haukcode.DinkToPdf IronPDF
Motor subjacente wkhtmltopdf (Qt WebKit ~2015) Chromium (atualizado regularmente)
Estado de segurança CVE-2022-35583 (CRÍTICO, sem solução) Ativamente corrigido
Status do projeto Desdobramento de projeto abandonado Desenvolvido ativamente
HTML5/CSS3 Limitado Apoiado
JavaScript Limitado, inseguro Motor V8 completo
Binários nativos Obrigatório (específico da plataforma) Autossuficiente
Segurança da rosca Requer padrão singleton Projetado para ser seguro contra roscas.
Apoiar Apenas para a comunidade Suporte profissional
Atualizações Nenhuma esperada Lançamentos regulares
Licença MIT (Gratuito) Comercial com período de teste gratuito

Guia rápido: Migração de Haukcode.DinkToPdf para IronPDF

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

Passo 1: Remova o DinkToPdf e os binários nativos.

Remova os pacotes NuGet Haukcode.DinkToPdf:

# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet
# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet
SHELL

Exclua os binários nativos do seu projeto:

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

Passo 2: Instale o IronPDF

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Etapa 3: Atualizar Namespaces

Substitua os namespaces DinkToPdf por IronPDF:

// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
Imports IronPdf
Imports IronPdf.Rendering
$vbLabelText   $csharpLabel

Etapa 4: 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

Conversão básica de HTML para PDF

A operação mais fundamental revela a diferença de complexidade entre essas bibliotecas PDF do .NET .

Abordagem Haukcode.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 = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };

        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 = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };

        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 List(Of ObjectSettings) From {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Hello World</h1></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");

        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");

        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")

        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Haukcode.DinkToPdf requer a criação de um SynchronizedConverter com PdfTools, a construção de um HtmlToPdfDocument com GlobalSettings e Objects aninhados, a adição de um ObjectSettings com HtmlContent, a chamada de converter.Convert() para obter bytes brutos e a escrita manual em um arquivo com File.WriteAllBytes().

O IronPDF simplifica isso para três linhas: criar um ChromePdfRenderer, chamar RenderHtmlAsPdf() e usar o método integrado SaveAs().

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

Converter URLs em PDF

A conversão de URL para PDF mostra diferenças de padrão semelhantes.

Abordagem Haukcode.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

Abordagem 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

Haukcode.DinkToPdf usa o mesmo padrão de construção de documento com ObjectSettings.Page para URLs. O IronPDF fornece um método dedicado RenderUrlAsPdf() que expressa claramente a intenção.

Consulte a documentação sobre URLs para PDF para obter informações sobre autenticação e opções de cabeçalho personalizadas.

Configurações de página personalizadas

Configurar a orientação, o tamanho do papel e as margens requer abordagens diferentes.

Abordagem Haukcode.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.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.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.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.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.Letter,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("landscape.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");

        pdf.SaveAs("landscape.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");

        pdf.SaveAs("landscape.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>")

        pdf.SaveAs("landscape.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Haukcode.DinkToPdf aninha configurações dentro de GlobalSettings com um objeto MarginSettings separado. O IronPDF fornece propriedades RenderingOptions diretas com nomes claros como PaperSize, PaperOrientation e propriedades de margem individuais.

Referência de mapeamento da API Haukcode.DinkToPdf para IronPDF

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

Mapeamento de Classe de Conversão

Haukcode.DinkToPdf IronPDF
SynchronizedConverter ChromePdfRenderer
BasicConverter ChromePdfRenderer
PdfTools N / D
IConverter N / D

Mapeamento de Configuração de Documentos

Haukcode.DinkToPdf IronPDF
HtmlToPdfDocument Chamada de método
GlobalSettings RenderingOptions
ObjectSettings RenderingOptions
converter.Convert(doc) renderer.RenderHtmlAsPdf(html)

Mapeamento de propriedades do GlobalSettings

Propriedade GlobalSettings Propriedade IronPDF
ColorMode RenderingOptions.GrayScale
Orientation RenderingOptions.PaperOrientation
PaperSize RenderingOptions.PaperSize
Margins.Top RenderingOptions.MarginTop
Margins.Bottom RenderingOptions.MarginBottom
Margins.Left RenderingOptions.MarginLeft
Margins.Right RenderingOptions.MarginRight

Mapeamento de propriedades de configurações de objeto

Propriedade ObjectSettings Equivalente ao IronPDF
HtmlContent Primeiro parâmetro para RenderHtmlAsPdf()
Page (URL) renderer.RenderUrlAsPdf(url)
HeaderSettings.Right = "[page]" TextHeader.RightText = "{page}"

Migração de sintaxe de espaço reservado

Haukcode.DinkToPdf IronPDF
[page] {page}
[toPage] {total-pages}
[date] {date}

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

Problema 1: Requisito de Singleton

Haukcode.DinkToPdf: Requer SynchronizedConverter como singleton devido a problemas de segurança de threads com o binário nativo wkhtmltopdf.

Solução: O ChromePdfRenderer do IronPDF é thread-safe por design — não requer singleton:

// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
' Before (DinkToPdf) - MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton(Of IPdfService, IronPdfService)()
' Or services.AddTransient(Of IPdfService, IronPdfService)() - both are safe!
$vbLabelText   $csharpLabel

Problema 2: Dependências binárias nativas

Haukcode.DinkToPdf: Requer bibliotecas nativas específicas da plataforma (libwkhtmltox.dll/so/dylib).

Solução: O IronPDF é autossuficiente e não possui dependências binárias nativas. Exclua estes arquivos após a migração:

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

Questão 3: Diferenças nos tipos de retorno

Haukcode.DinkToPdf: converter.Convert() retorna byte[] diretamente.

Solução: O IronPDF retorna um objeto PdfDocument com várias opções de saída:

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly
var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes
pdf.SaveAs("output.pdf")  ' Or save directly
$vbLabelText   $csharpLabel

Problema 4: Sintaxe de espaço reservado para cabeçalho/rodapé

Haukcode.DinkToPdf: Usa a sintaxe de colchetes como [page] e [toPage].

Solução: Atualize os marcadores de posição para chaves do IronPDF:

// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    RightText = "Page {page} of {total-pages}"
};
// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    RightText = "Page {page} of {total-pages}"
};
' Before (DinkToPdf)
HeaderSettings = New With {.Right = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .RightText = "Page {page} of {total-pages}"
}
$vbLabelText   $csharpLabel

Lista de verificação para migração de Haukcode.DinkToPdf

Tarefas pré-migração

Faça uma auditoria em seu código-fonte para identificar todos os usos do DinkToPdf:

# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .
# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .
SHELL

Documente as configurações atuais de GlobalSettings e ObjectSettings. Identifique qualquer código de carregamento de biblioteca nativa que possa ser removido.

Tarefas de atualização de código

  1. Remova os pacotes NuGet do DinkToPdf
  2. Instale o pacote NuGet IronPDF
  3. Atualize as importações de namespace de DinkToPdf para IronPdf
  4. Substitua SynchronizedConverter por ChromePdfRenderer
  5. Converter padrões HtmlToPdfDocument em chamadas de método diretas
  6. Converter GlobalSettings para RenderingOptions
  7. Converter ObjectSettings para RenderingOptions
  8. Atualizar a sintaxe do marcador de posição ([page] → {page}, [toPage] → {total-pages})
  9. Adicionar inicialização da licença do IronPDF na inicialização do sistema.

Tarefas de limpeza de infraestrutura

  1. Exclua os binários nativos (libwkhtmltox.*)
  2. Remover o código de carregamento da biblioteca nativa
  3. Remova o CustomAssemblyLoadContext, se presente.
  4. Atualizar Injeção de Dependência (singleton não é mais necessário)
  5. Remover o código de detecção de plataforma para binários nativos

Testes pós-migração

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

  • Teste de conversão de HTML para PDF
  • Teste de conversão de URL para PDF
  • Verificar as configurações da página (tamanho, orientação, margens)
  • Verificar cabeçalhos e rodapés com marcadores de posição
  • Teste com modelos HTML reais
  • Teste de desempenho sob carga

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

A migração do Haukcode.DinkToPdf para o IronPDF oferece diversas vantagens importantes:

Segurança: Elimina a vulnerabilidade CVE-2022-35583 (SSRF) e outras vulnerabilidades do wkhtmltopdf que nunca serão corrigidas.

Mecanismo de renderização moderno: utiliza o Chromium, que recebe atualizações constantes, em vez do Qt WebKit, abandonado em 2015. Suporte completo a HTML5, CSS3 e JavaScript .

Sem binários nativos: Biblioteca autocontida, sem DLLs específicas da plataforma para gerenciar. Simplifica a implementação em Windows, Linux e macOS.

Segurança de threads: Sem requisito de singleton — use ChromePdfRenderer livremente em qualquer padrão, incluindo instanciação por requisição.

API mais simples: Chamadas de método diretas (RenderHtmlAsPdf(), RenderUrlAsPdf()) em vez da construção complexa de objetos de documento.

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