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. Migre do Foxit PDF SDK para o IronPDF
GUIAS DE MIGRAçãO

Migrar do Foxit PDF SDK para o IronPDF: (Guia .NET)

Curtis Chau
Curtis Chau
Atualizado:

A migração do SDK de PDF da Foxit para o IronPDF simplifica seu fluxo de trabalho de geração de PDFs em .NET , substituindo APIs complexas voltadas para empresas por padrões modernos e fáceis de usar para desenvolvedores. Este guia fornece um caminho de migração completo, passo a passo, que remove código desnecessário e facilita as operações com PDFs em toda a sua base de código.

Por que migrar do SDK de PDF da Foxit para o IronPDF?

Os desafios do Foxit PDF

O SDK de PDF da Foxit é uma biblioteca robusta de nível empresarial, mas apresenta uma complexidade significativa que pode atrasar o desenvolvimento:

  1. Sistema de licenciamento complexo: A variedade de produtos, SKUs e tipos de licença (por desenvolvedor, por servidor, OEM, etc.) dificulta a escolha da opção ideal para o seu projeto.

  2. Preços para empresas: Os preços são personalizados para grandes organizações e podem ser proibitivos para equipes menores ou desenvolvedores individuais.

  3. Pacote Nativo Pesado: O pacote público NuGet (Foxit.SDK.Dotnet) é grande (~240 MB), e projetos mais antigos ainda podem conter referências diretas de DLL ou configurações de feeds privados.

  4. API Verbosa: A inicialização da biblioteca com Library.Initialize(), a verificação de códigos de erro e chamadas explícitas Library.Release() adicionam boilerplate a cada operação.

  5. Motor HTML2PDF Separado: A conversão de HTML para PDF requer os binários do motor HTML2PDF, distribuídos separadamente do suporte/vendas do Foxit, em vez de incluídos no pacote NuGet.

  6. Configuração Complexa: As configurações requerem configuração detalhada de objetos (por exemplo, HTML2PDFSettingData) com múltiplas propriedades.

  7. Herança do C++: Os padrões da API refletem as origens do C++, parecendo menos naturais em aplicações C# modernas.

Comparação entre Foxit PDF e IronPDF

Aspecto SDK de PDF da Foxit IronPDF
Instalação Foxit.SDK.Dotnet (~240 MB) + motor HTML2PDF separado Pacote NuGet simples
Licenciamento Conduzido por vendas, por desenvolvedor por plataforma Transparente, adequado para todos os tamanhos.
Inicialização Library.Initialize(sn, key) Defina a chave de licença uma vez.
Tratamento de erros Enumerações de código de erro Exceções padrão do .NET
HTML para PDF Download de motor separado Motor Chromium integrado
Estilo API Herança do C++, verboso Padrões modernos do .NET
Limpeza de recursos Manual Release() Descartável/automático
Documentação Portal de documentos corporativos Tutoriais públicos

Análise de custo-benefício

Mudar de Foxit PDF para IronPDF oferece benefícios de desenvolvimento tangíveis: complexidade reduzida por meio de APIs mais simples, desenvolvimento mais rápido com métodos intuitivos, compatibilidade com .NET moderno, incluindo suporte a async/await e LINQ, uma abordagem centrada em HTML que usa habilidades web existentes e conversão de HTML incluída sem download de motor separado.IronPDF roda nas versões atuais do .NET e combina perfeitamente com padrões de C# modernos.

Antes de começar

Pré-requisitos

  1. Ambiente .NET : O IronPDF é compatível com .NET Framework 4.6.2+, .NET Core 3.1+, .NET 5/6/7/8/9+
  2. Acesso ao NuGet : Certifique-se de que você pode instalar pacotes do NuGet.
  3. Chave de licença: Obtenha sua chave de licença do IronPDF para uso em produção em IronPDF.

Faça backup do seu projeto

# Create a backup branch
git checkout -b pre-ironpdf-migration
git add .
git commit -m "Backup before SDK de PDF da Foxit to IronPDF migration"
# Create a backup branch
git checkout -b pre-ironpdf-migration
git add .
git commit -m "Backup before SDK de PDF da Foxit to IronPDF migration"
SHELL

Identificar todos os usos do Foxit PDF

# Find all SDK de PDF da Foxit references
grep -r "foxit\|PDFDoc\|PDFPage\|Library.Initialize\|Library.Release" --include="*.cs" --include="*.csproj" .

# Find Foxit DLL references
find . -name "*.csproj" | xargs grep -l "Foxit\|fsdk"
# Find all SDK de PDF da Foxit references
grep -r "foxit\|PDFDoc\|PDFPage\|Library.Initialize\|Library.Release" --include="*.cs" --include="*.csproj" .

# Find Foxit DLL references
find . -name "*.csproj" | xargs grep -l "Foxit\|fsdk"
SHELL

Funcionalidade atual do documento

Antes da migração, catalogar:

  • Quais recursos do Foxit PDF você utiliza (conversão para HTML, anotações, formulários, segurança)?
  • Localização da chave de licença e código de inicialização
  • Configurações e definições personalizadas
  • Padrões de tratamento de erros usando enumerações ErrorCode

Migração de Início Rápido

Passo 1: Atualizar pacotes NuGet

# Remove the Foxit NuGet package
dotnet remove package Foxit.SDK.Dotnet

# Install IronPDF
dotnet add package IronPdf
# Remove the Foxit NuGet package
dotnet remove package Foxit.SDK.Dotnet

# Install IronPDF
dotnet add package IronPdf
SHELL

Se você tem referências diretas mais antigas de DLL do Foxit no .csproj (construções mais antigas), remova-as manualmente:


<Reference Include="fsdk_dotnet">
    <HintPath>..\libs\Foxit\fsdk_dotnet.dll</HintPath>
</Reference>

<Reference Include="fsdk_dotnet">
    <HintPath>..\libs\Foxit\fsdk_dotnet.dll</HintPath>
</Reference>
XML

Além disso, exclua quaisquer pastas de motor HTML2PDF que foram descompactadas separadamente.

Etapa 2: Atualizar Namespaces

// Before (Foxit PDF)
using foxit;
using foxit.common;
using foxit.common.fxcrt;
using foxit.pdf;
using foxit.pdf.annots;
using foxit.addon.conversion;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;
// Before (Foxit PDF)
using foxit;
using foxit.common;
using foxit.common.fxcrt;
using foxit.pdf;
using foxit.pdf.annots;
using foxit.addon.conversion;

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

Etapa 3: Inicializar o IronPDF

Uma das melhorias mais significativas nesta migração para o Foxit PDF é a eliminação do padrão complexo de inicialização e limpeza:

// Before (Foxit PDF)
string sn = "YOUR_SERIAL_NUMBER";
string key = "YOUR_LICENSE_KEY";
ErrorCode error_code = Library.Initialize(sn, key);
if (error_code != ErrorCode.e_ErrSuccess)
{
    throw new Exception("Failed to initialize Foxit PDF SDK");
}
// ... your code ...
Library.Release();  // Don't forget this!

// After (IronPDF)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// That's it! No Release() needed
// Before (Foxit PDF)
string sn = "YOUR_SERIAL_NUMBER";
string key = "YOUR_LICENSE_KEY";
ErrorCode error_code = Library.Initialize(sn, key);
if (error_code != ErrorCode.e_ErrSuccess)
{
    throw new Exception("Failed to initialize Foxit PDF SDK");
}
// ... your code ...
Library.Release();  // Don't forget this!

// After (IronPDF)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// That's it! No Release() needed
Imports System

' Before (Foxit PDF)
Dim sn As String = "YOUR_SERIAL_NUMBER"
Dim key As String = "YOUR_LICENSE_KEY"
Dim error_code As ErrorCode = Library.Initialize(sn, key)
If error_code <> ErrorCode.e_ErrSuccess Then
    Throw New Exception("Failed to initialize Foxit PDF SDK")
End If
' ... your code ...
Library.Release()  ' Don't forget this!

' After (IronPDF)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' That's it! No Release() needed
$vbLabelText   $csharpLabel

Etapa 4: Padrão de Conversão Básico

// Before (Foxit PDF)
Library.Initialize(sn, key);
HTML2PDFSettingData settings = new HTML2PDFSettingData();
settings.page_width = 612.0f;
settings.page_height = 792.0f;
Convert.FromHTML(htmlContent, @"C:\Foxit\html2pdf_engine", "",
                 settings, "output.pdf", 30);
Library.Release();

// After (IronPDF)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
// Before (Foxit PDF)
Library.Initialize(sn, key);
HTML2PDFSettingData settings = new HTML2PDFSettingData();
settings.page_width = 612.0f;
settings.page_height = 792.0f;
Convert.FromHTML(htmlContent, @"C:\Foxit\html2pdf_engine", "",
                 settings, "output.pdf", 30);
Library.Release();

// After (IronPDF)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
' Before (Foxit PDF)
Library.Initialize(sn, key)
Dim settings As New HTML2PDFSettingData()
settings.page_width = 612.0F
settings.page_height = 792.0F
Convert.FromHTML(htmlContent, "C:\Foxit\html2pdf_engine", "", settings, "output.pdf", 30)
Library.Release()

' After (IronPDF)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Referência completa da API

Mapeamento de Namespace

Espaço de nomes PDF do Foxit Equivalente ao IronPDF
foxit IronPdf
foxit.common IronPdf
foxit.common.fxcrt N / D
foxit.pdf IronPdf
foxit.pdf.annots IronPdf.Editing
foxit.addon.conversion IronPdf.Rendering

Mapeamento de Classes Principais

Classe do SDK Foxit PDF Equivalente ao IronPDF
Library N / D
PDFDoc PdfDocument
PDFPage PdfDocument.Pages[i]
HTML2PDF ChromePdfRenderer
TextPage pdf.ExtractTextFromPage(i)
Watermark TextStamper / ImageStamper
Security SecuritySettings
Form pdf.Form
Metadata pdf.MetaData

Métodos PDFDoc

Foxit PDFDoc IronPDF Documento PDF
new PDFDoc(path) PdfDocument.FromFile(path)
doc.LoadW(password) PdfDocument.FromFile(path, password)
doc.GetPageCount() pdf.PageCount
doc.GetPage(index) pdf.Pages[index]
doc.SaveAs(path, flags) pdf.SaveAs(path)
doc.Close() pdf.Dispose() ou declaração de using
doc.InsertDocument() PdfDocument.Merge()

Conversão de HTML para PDF

Foxit HTML2PDF Equivalente ao IronPDF
new HTML2PDFSettingData() new ChromePdfRenderer()
settings.page_width RenderingOptions.PaperSize
settings.page_height RenderingOptions.SetCustomPaperSize()
Convert.FromHTML(html, engine, ...) renderer.RenderHtmlAsPdf(html)
Convert.FromHTML(url, engine, ...) renderer.RenderUrlAsPdf(url)

Configurações de marca d'água

Marca d'água Foxit Equivalente ao IronPDF
new Watermark(doc, text, font, size, color) new TextStamper()
WatermarkSettings.position VerticalAlignment + HorizontalAlignment
WatermarkSettings.rotation Rotation
WatermarkSettings.opacity Opacity
watermark.InsertToAllPages() pdf.ApplyStamp(stamper)

Exemplos de código

Exemplo 1: Conversão de HTML para PDF

Antes (SDK do Foxit PDF):

// NuGet: Install-Package Foxit.SDK.Dotnet
// HTML-to-PDF requires the separateFoxit HTML2PDFengine (engine_path),
// obtained from Foxit support/sales — not in the NuGet package.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        HTML2PDFSettingData settingData = new HTML2PDFSettingData();
        settingData.page_width = 612.0f;
        settingData.page_height = 792.0f;
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;

        Convert.FromHTML(
            "<html><body><h1>Hello World</h1></body></html>",
            @"C:\Foxit\html2pdf_engine",   // engine_path (separate download)
            "",                              // cookies path
            settingData,
            "output.pdf",
            30);                             // timeout (seconds)

        Library.Release();
    }
}
// NuGet: Install-Package Foxit.SDK.Dotnet
// HTML-to-PDF requires the separateFoxit HTML2PDFengine (engine_path),
// obtained from Foxit support/sales — not in the NuGet package.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        HTML2PDFSettingData settingData = new HTML2PDFSettingData();
        settingData.page_width = 612.0f;
        settingData.page_height = 792.0f;
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;

        Convert.FromHTML(
            "<html><body><h1>Hello World</h1></body></html>",
            @"C:\Foxit\html2pdf_engine",   // engine_path (separate download)
            "",                              // cookies path
            settingData,
            "output.pdf",
            30);                             // timeout (seconds)

        Library.Release();
    }
}
Imports foxit
Imports foxit.common
Imports foxit.addon.conversion
Imports System

Module Program
    Sub Main()
        Library.Initialize("sn", "key")

        Dim settingData As New HTML2PDFSettingData()
        settingData.page_width = 612.0F
        settingData.page_height = 792.0F
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage

        Convert.FromHTML(
            "<html><body><h1>Hello World</h1></body></html>",
            "C:\Foxit\html2pdf_engine",   ' engine_path (separate download)
            "",                           ' cookies path
            settingData,
            "output.pdf",
            30)                          ' timeout (seconds)

        Library.Release()
    End Sub
End Module
$vbLabelText   $csharpLabel

Após (IronPDF):

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

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;

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

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

A abordagem IronPDF reduz mais de 15 linhas de código de configuração para apenas 4 linhas. Sem inicialização de biblioteca, sem limpeza explícita, sem objetos de configuração complexos. Para obter mais opções de renderização HTML, consulte a documentação de HTML para PDF .

Exemplo 2: Conversão de URL para PDF

Antes (SDK do Foxit PDF):

// NuGet: Install-Package Foxit.SDK.Dotnet
// Convert.FromHTML accepts either a URL or a literal HTML string in the
// first argument; the URL form is what does URL-to-PDF.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        HTML2PDFSettingData settingData = new HTML2PDFSettingData();
        settingData.page_width = 612.0f;
        settingData.page_height = 792.0f;
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;

        Convert.FromHTML(
            "https://www.example.com",
            @"C:\Foxit\html2pdf_engine",   // engine_path (separate download)
            "",                              // cookies path
            settingData,
            "output.pdf",
            30);                             // timeout (seconds)

        Library.Release();
    }
}
// NuGet: Install-Package Foxit.SDK.Dotnet
// Convert.FromHTML accepts either a URL or a literal HTML string in the
// first argument; the URL form is what does URL-to-PDF.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        HTML2PDFSettingData settingData = new HTML2PDFSettingData();
        settingData.page_width = 612.0f;
        settingData.page_height = 792.0f;
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;

        Convert.FromHTML(
            "https://www.example.com",
            @"C:\Foxit\html2pdf_engine",   // engine_path (separate download)
            "",                              // cookies path
            settingData,
            "output.pdf",
            30);                             // timeout (seconds)

        Library.Release();
    }
}
Imports foxit
Imports foxit.common
Imports foxit.addon.conversion
Imports System

Module Program
    Sub Main()
        Library.Initialize("sn", "key")

        Dim settingData As New HTML2PDFSettingData()
        settingData.page_width = 612.0F
        settingData.page_height = 792.0F
        settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage

        Convert.FromHTML(
            "https://www.example.com",
            "C:\Foxit\html2pdf_engine",   ' engine_path (separate download)
            "",                           ' cookies path
            settingData,
            "output.pdf",
            30)                          ' timeout (seconds)

        Library.Release()
    End Sub
End Module
$vbLabelText   $csharpLabel

Após (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("output.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("output.pdf");
    }
}
Imports IronPdf
Imports System

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

O mecanismo Chromium integrado do IronPDF lida automaticamente com a execução de JavaScript , a renderização de CSS e o conteúdo dinâmico. Saiba mais sobre a conversão de URL para PDF .

Exemplo 3: Adicionando marcas d'água

Antes (SDK do Foxit PDF):

// NuGet: Install-Package Foxit.SDK.Dotnet
using foxit;
using foxit.common;
using foxit.pdf;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        using (PDFDoc doc = new PDFDoc("input.pdf"))
        {
            doc.Load("");

            WatermarkSettings settings = new WatermarkSettings();
            settings.flags = (int)Watermark.Flags.e_FlagASPageContents;
            settings.position = Position.e_PosCenter;
            settings.rotation = -45.0f;
            settings.opacity = 50;     // 0-100 in newer SDKs

            WatermarkTextProperties props = new WatermarkTextProperties();
            props.font = new Font(Font.StandardID.e_StdIDHelvetica);
            props.font_size = 48.0f;
            props.color = 0xFF0000;
            props.alignment = Alignment.e_AlignmentCenter;

            Watermark watermark = new Watermark(doc, "Confidential", props, settings);

            // No InsertToAllPages helper — iterate pages explicitly.
            for (int i = 0; i < doc.GetPageCount(); i++)
            {
                using (PDFPage page = doc.GetPage(i))
                {
                    watermark.InsertToPage(page);
                }
            }

            doc.SaveAs("output.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
        }

        Library.Release();
    }
}
// NuGet: Install-Package Foxit.SDK.Dotnet
using foxit;
using foxit.common;
using foxit.pdf;
using System;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        using (PDFDoc doc = new PDFDoc("input.pdf"))
        {
            doc.Load("");

            WatermarkSettings settings = new WatermarkSettings();
            settings.flags = (int)Watermark.Flags.e_FlagASPageContents;
            settings.position = Position.e_PosCenter;
            settings.rotation = -45.0f;
            settings.opacity = 50;     // 0-100 in newer SDKs

            WatermarkTextProperties props = new WatermarkTextProperties();
            props.font = new Font(Font.StandardID.e_StdIDHelvetica);
            props.font_size = 48.0f;
            props.color = 0xFF0000;
            props.alignment = Alignment.e_AlignmentCenter;

            Watermark watermark = new Watermark(doc, "Confidential", props, settings);

            // No InsertToAllPages helper — iterate pages explicitly.
            for (int i = 0; i < doc.GetPageCount(); i++)
            {
                using (PDFPage page = doc.GetPage(i))
                {
                    watermark.InsertToPage(page);
                }
            }

            doc.SaveAs("output.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
        }

        Library.Release();
    }
}
Imports foxit
Imports foxit.common
Imports foxit.pdf
Imports System

Module Program
    Sub Main()
        Library.Initialize("sn", "key")

        Using doc As New PDFDoc("input.pdf")
            doc.Load("")

            Dim settings As New WatermarkSettings()
            settings.flags = CInt(Watermark.Flags.e_FlagASPageContents)
            settings.position = Position.e_PosCenter
            settings.rotation = -45.0F
            settings.opacity = 50 ' 0-100 in newer SDKs

            Dim props As New WatermarkTextProperties()
            props.font = New Font(Font.StandardID.e_StdIDHelvetica)
            props.font_size = 48.0F
            props.color = &HFF0000
            props.alignment = Alignment.e_AlignmentCenter

            Dim watermark As New Watermark(doc, "Confidential", props, settings)

            ' No InsertToAllPages helper — iterate pages explicitly.
            For i As Integer = 0 To doc.GetPageCount() - 1
                Using page As PDFPage = doc.GetPage(i)
                    watermark.InsertToPage(page)
                End Using
            Next

            doc.SaveAs("output.pdf", CInt(PDFDoc.SaveFlags.e_SaveFlagNoOriginal))
        End Using

        Library.Release()
    End Sub
End Module
$vbLabelText   $csharpLabel

Após (IronPDF):

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

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");
        pdf.ApplyWatermark(new TextStamper()
        {
            Text = "Confidential",
            FontSize = 48,
            Opacity = 50,
            Rotation = -45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        });
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");
        pdf.ApplyWatermark(new TextStamper()
        {
            Text = "Confidential",
            FontSize = 48,
            Opacity = 50,
            Rotation = -45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        });
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Editing
Imports System

Class Program
    Shared Sub Main()
        Dim pdf = PdfDocument.FromFile("input.pdf")
        pdf.ApplyWatermark(New TextStamper() With {
            .Text = "Confidential",
            .FontSize = 48,
            .Opacity = 50,
            .Rotation = -45,
            .VerticalAlignment = VerticalAlignment.Middle,
            .HorizontalAlignment = HorizontalAlignment.Center
        })
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

O TextStamper do IronPDF proporciona configuração intuitiva baseada em propriedades em vez de objetos de configuração separados e iteração manual de páginas. Consulte a documentação completa sobre marca d'água para obter opções adicionais.

Exemplo 4: URL para PDF com cabeçalhos e rodapés

Antes (SDK do Foxit PDF):

using foxit;
using foxit.addon.conversion;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        try
        {
            HTML2PDFSettingData settings = new HTML2PDFSettingData();
            settings.page_width = 595.0f;  // A4
            settings.page_height = 842.0f;
            settings.page_margin_top = 100.0f;
            settings.page_margin_bottom = 100.0f;

            // SDK de PDF da Foxit has limited header/footer support
            // Often requires post-processing or additional code

            Convert.FromHTML(
                "https://www.example.com",
                @"C:\Foxit\html2pdf_engine",  // engine_path (separate download)
                "",                            // cookies path
                settings,
                "webpage.pdf",
                30);                           // timeout (seconds)
        }
        finally
        {
            Library.Release();
        }
    }
}
using foxit;
using foxit.addon.conversion;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        try
        {
            HTML2PDFSettingData settings = new HTML2PDFSettingData();
            settings.page_width = 595.0f;  // A4
            settings.page_height = 842.0f;
            settings.page_margin_top = 100.0f;
            settings.page_margin_bottom = 100.0f;

            // SDK de PDF da Foxit has limited header/footer support
            // Often requires post-processing or additional code

            Convert.FromHTML(
                "https://www.example.com",
                @"C:\Foxit\html2pdf_engine",  // engine_path (separate download)
                "",                            // cookies path
                settings,
                "webpage.pdf",
                30);                           // timeout (seconds)
        }
        finally
        {
            Library.Release();
        }
    }
}
Imports foxit
Imports foxit.addon.conversion

Class Program
    Shared Sub Main()
        Library.Initialize("sn", "key")

        Try
            Dim settings As New HTML2PDFSettingData()
            settings.page_width = 595.0F ' A4
            settings.page_height = 842.0F
            settings.page_margin_top = 100.0F
            settings.page_margin_bottom = 100.0F

            ' SDK de PDF da Foxit has limited header/footer support
            ' Often requires post-processing or additional code

            Convert.FromHTML(
                "https://www.example.com",
                "C:\Foxit\html2pdf_engine", ' engine_path (separate download)
                "", ' cookies path
                settings,
                "webpage.pdf",
                30) ' timeout (seconds)
        Finally
            Library.Release()
        End Try
    End Sub
End Class
$vbLabelText   $csharpLabel

Após (IronPDF):

using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.WaitFor.RenderDelay(3000);  // Wait for JS

        // Built-in header/footer support
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center; font-size:12pt;'>Company Report</div>",
            DrawDividerLine = true
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
            DrawDividerLine = true
        };

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.WaitFor.RenderDelay(3000);  // Wait for JS

        // Built-in header/footer support
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center; font-size:12pt;'>Company Report</div>",
            DrawDividerLine = true
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
            DrawDividerLine = true
        };

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.WaitFor.RenderDelay(3000) ' Wait for JS

        ' Built-in header/footer support
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:center; font-size:12pt;'>Company Report</div>",
            .DrawDividerLine = True
        }

        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
            .DrawDividerLine = True
        }

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

O IronPDF oferece suporte nativo a cabeçalhos e rodapés com estilo HTML e marcadores de posição dinâmicos para números de página.

Exemplo 5: Segurança e criptografia de PDF

Antes (SDK do Foxit PDF):

using foxit;
using foxit.pdf;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        try
        {
            using (PDFDoc doc = new PDFDoc("input.pdf"))
            {
                doc.LoadW("");

                // Build the encryption data (cipher, key length, permissions)
                using (StdEncryptData encryptData = new StdEncryptData(
                    true,                                    // is_encrypt_metadata
                    (int)(PDFDoc.UserPermissions.e_PermPrint |
                          PDFDoc.UserPermissions.e_PermModify),
                    SecurityHandler.CipherType.e_CipherAES,
                    16))                                     // key length (bytes) -> AES-128
                using (StdSecurityHandler securityHandler = new StdSecurityHandler())
                {
                    securityHandler.Initialize(encryptData, "user_password", "owner_password");
                    doc.SetSecurityHandler(securityHandler);
                }

                doc.SaveAs("encrypted.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
            }
        }
        finally
        {
            Library.Release();
        }
    }
}
using foxit;
using foxit.pdf;

class Program
{
    static void Main()
    {
        Library.Initialize("sn", "key");

        try
        {
            using (PDFDoc doc = new PDFDoc("input.pdf"))
            {
                doc.LoadW("");

                // Build the encryption data (cipher, key length, permissions)
                using (StdEncryptData encryptData = new StdEncryptData(
                    true,                                    // is_encrypt_metadata
                    (int)(PDFDoc.UserPermissions.e_PermPrint |
                          PDFDoc.UserPermissions.e_PermModify),
                    SecurityHandler.CipherType.e_CipherAES,
                    16))                                     // key length (bytes) -> AES-128
                using (StdSecurityHandler securityHandler = new StdSecurityHandler())
                {
                    securityHandler.Initialize(encryptData, "user_password", "owner_password");
                    doc.SetSecurityHandler(securityHandler);
                }

                doc.SaveAs("encrypted.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
            }
        }
        finally
        {
            Library.Release();
        }
    }
}
Imports foxit
Imports foxit.pdf

Class Program
    Shared Sub Main()
        Library.Initialize("sn", "key")

        Try
            Using doc As New PDFDoc("input.pdf")
                doc.LoadW("")

                ' Build the encryption data (cipher, key length, permissions)
                Using encryptData As New StdEncryptData(True, CType(PDFDoc.UserPermissions.e_PermPrint Or PDFDoc.UserPermissions.e_PermModify, Integer), SecurityHandler.CipherType.e_CipherAES, 16) ' key length (bytes) -> AES-128
                    Using securityHandler As New StdSecurityHandler()
                        securityHandler.Initialize(encryptData, "user_password", "owner_password")
                        doc.SetSecurityHandler(securityHandler)
                    End Using
                End Using

                doc.SaveAs("encrypted.pdf", CType(PDFDoc.SaveFlags.e_SaveFlagNoOriginal, Integer))
            End Using
        Finally
            Library.Release()
        End Try
    End Sub
End Class
$vbLabelText   $csharpLabel

Após (IronPDF):

using IronPdf;

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Set passwords
        pdf.SecuritySettings.OwnerPassword = "owner_password";
        pdf.SecuritySettings.UserPassword = "user_password";

        // Set permissions
        pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
        pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.EditAll;
        pdf.SecuritySettings.AllowUserCopyPasteContent = true;
        pdf.SecuritySettings.AllowUserAnnotations = true;

        pdf.SaveAs("encrypted.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("input.pdf");

        // Set passwords
        pdf.SecuritySettings.OwnerPassword = "owner_password";
        pdf.SecuritySettings.UserPassword = "user_password";

        // Set permissions
        pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
        pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.EditAll;
        pdf.SecuritySettings.AllowUserCopyPasteContent = true;
        pdf.SecuritySettings.AllowUserAnnotations = true;

        pdf.SaveAs("encrypted.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim pdf = PdfDocument.FromFile("input.pdf")

        ' Set passwords
        pdf.SecuritySettings.OwnerPassword = "owner_password"
        pdf.SecuritySettings.UserPassword = "user_password"

        ' Set permissions
        pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights
        pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.EditAll
        pdf.SecuritySettings.AllowUserCopyPasteContent = True
        pdf.SecuritySettings.AllowUserAnnotations = True

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

Considerações sobre o desempenho

Reutilize o ChromePdfRenderer

Para obter o melhor desempenho durante a sua migração de PDF Foxit, reutilize a instância ChromePdfRenderer — ela é thread-safe:

// GOOD - Reuse renderer (thread-safe)
public class PdfService
{
    private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] Generate(string html) => _renderer.RenderHtmlAsPdf(html).BinaryData;
}

// BAD - Creates new instance each time
public byte[] GenerateBad(string html)
{
    var renderer = new ChromePdfRenderer();  // Wasteful
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}
// GOOD - Reuse renderer (thread-safe)
public class PdfService
{
    private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] Generate(string html) => _renderer.RenderHtmlAsPdf(html).BinaryData;
}

// BAD - Creates new instance each time
public byte[] GenerateBad(string html)
{
    var renderer = new ChromePdfRenderer();  // Wasteful
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}
Imports System

Public Class PdfService
    Private Shared ReadOnly _renderer As New ChromePdfRenderer()

    Public Function Generate(html As String) As Byte()
        Return _renderer.RenderHtmlAsPdf(html).BinaryData
    End Function

    ' BAD - Creates new instance each time
    Public Function GenerateBad(html As String) As Byte()
        Dim renderer As New ChromePdfRenderer() ' Wasteful
        Return renderer.RenderHtmlAsPdf(html).BinaryData
    End Function
End Class
$vbLabelText   $csharpLabel

Auxiliar de Conversão de Unidades

O SDK Foxit PDF usa pontos; O IronPDF usa milímetros. Utilize esta ferramenta auxiliar durante a migração:

public static class UnitConverter
{
    public static double PointsToMm(double points) => points * 0.352778;
    public static double MmToPoints(double mm) => mm / 0.352778;
    public static double InchesToMm(double inches) => inches * 25.4;
}

// Usage: Convert Foxit's 72 points (1 inch) to IronPDF millimeters
renderer.RenderingOptions.MarginTop = UnitConverter.PointsToMm(72); // ~25.4mm
public static class UnitConverter
{
    public static double PointsToMm(double points) => points * 0.352778;
    public static double MmToPoints(double mm) => mm / 0.352778;
    public static double InchesToMm(double inches) => inches * 25.4;
}

// Usage: Convert Foxit's 72 points (1 inch) to IronPDF millimeters
renderer.RenderingOptions.MarginTop = UnitConverter.PointsToMm(72); // ~25.4mm
Public Module UnitConverter
    Public Function PointsToMm(points As Double) As Double
        Return points * 0.352778
    End Function

    Public Function MmToPoints(mm As Double) As Double
        Return mm / 0.352778
    End Function

    Public Function InchesToMm(inches As Double) As Double
        Return inches * 25.4
    End Function
End Module

' Usage: Convert Foxit's 72 points (1 inch) to IronPDF millimeters
renderer.RenderingOptions.MarginTop = UnitConverter.PointsToMm(72) ' ~25.4mm
$vbLabelText   $csharpLabel

Descarte adequado de recursos

// GOOD - Using statement for automatic cleanup
using (var pdf = PdfDocument.FromFile("large.pdf"))
{
    string text = pdf.ExtractAllText();
}  // pdf is disposed automatically
// GOOD - Using statement for automatic cleanup
using (var pdf = PdfDocument.FromFile("large.pdf"))
{
    string text = pdf.ExtractAllText();
}  // pdf is disposed automatically
Imports PdfDocument

' GOOD - Using block for automatic cleanup
Using pdf = PdfDocument.FromFile("large.pdf")
    Dim text As String = pdf.ExtractAllText()
End Using ' pdf is disposed automatically
$vbLabelText   $csharpLabel

Solução de problemas

Problema 1: Library.Initialize() não encontrado

Problem: Library.Initialize() doesn't exist in IronPDF.

Solução: O IronPDF utiliza um padrão de inicialização mais simples:

// Foxit PDF
Library.Initialize(sn, key);

//IronPDF- just set license key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Foxit PDF
Library.Initialize(sn, key);

//IronPDF- just set license key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
$vbLabelText   $csharpLabel

Problema 2: Tratamento de Códigos de Erro

Problema: O código verifica ErrorCode.e_ErrSuccess, mas o IronPDF não possui isso.

Solução: Utilize o tratamento de exceções padrão do .NET :

// Foxit PDF
ErrorCode err = doc.LoadW("");
if (err != ErrorCode.e_ErrSuccess) { /* handle error */ }

// IronPDF
try
{
    var pdf = PdfDocument.FromFile("input.pdf");
}
catch (IOException ex)
{
    Console.WriteLine($"Failed to load PDF: {ex.Message}");
}
// Foxit PDF
ErrorCode err = doc.LoadW("");
if (err != ErrorCode.e_ErrSuccess) { /* handle error */ }

// IronPDF
try
{
    var pdf = PdfDocument.FromFile("input.pdf");
}
catch (IOException ex)
{
    Console.WriteLine($"Failed to load PDF: {ex.Message}");
}
Imports System
Imports System.IO

' Foxit PDF
Dim err As ErrorCode = doc.LoadW("")
If err <> ErrorCode.e_ErrSuccess Then
    ' handle error
End If

' IronPDF
Try
    Dim pdf = PdfDocument.FromFile("input.pdf")
Catch ex As IOException
    Console.WriteLine($"Failed to load PDF: {ex.Message}")
End Try
$vbLabelText   $csharpLabel

Problema 3: PDFDoc.Close() não encontrado

Problema: O método doc.Close() não existe no IronPDF.

Solução: Use declarações Dispose() ou using:

// Foxit PDF
doc.Close();

// IronPDF
pdf.Dispose();
// or better: wrap in using statement
// Foxit PDF
doc.Close();

// IronPDF
pdf.Dispose();
// or better: wrap in using statement
$vbLabelText   $csharpLabel

Lista de verificação para migração

Pré-migração

  • Inventariar todos os recursos do SDK de PDF da Foxit utilizados.
  • Localização das chaves de licença do documento
  • Anote todas as chamadas Library.Initialize() e Library.Release()
  • Listar configurações personalizadas (tamanhos de página, margens, etc.)
  • Identificar padrões de tratamento de erros usando ErrorCode
  • Fazer backup do projeto para o controle de versão
  • Obtenha a chave de licença do IronPDF

Migração de Pacotes

  • Remover as referências à DLL do SDK de PDF da Foxit do arquivo .csproj
  • Remova quaisquer configurações privadas de feeds NuGet
  • Instale o pacote IronPDF NuGet: dotnet add package IronPdf
  • Atualizar importações de namespace
  • Defina a chave de licença do IronPDF na inicialização.

Migração de código

  • Remova as chamadas Library.Initialize() e Library.Release()
  • Substitua as verificações ErrorCode por try/catch
  • Substitua PDFDoc por PdfDocument
  • Substitua Convert.FromHTML(...) por ChromePdfRenderer
  • Atualize o acesso à página de GetPage(i) para Pages[i]
  • Substitua SaveAs(path, flags) por SaveAs(path)
  • Substitua Close() por Dispose() ou declarações de using
  • Atualize o código de marca d'água para usar TextStamper
  • Converter unidades de pontos para milímetros

Testando

  • Verificar se a saída de HTML para PDF corresponde às expectativas.
  • Testar o carregamento de PDF e a extração de texto
  • Verificar a funcionalidade de mesclagem
  • Verificar a aparência da marca d'água
  • Testar recursos de segurança/criptografia
  • Validar operações de campos de formulário
  • Testes de desempenho

Pós-migração

  • Excluir DLLs do SDK do Foxit PDF
  • Remover arquivos de configuração relacionados ao Foxit
  • Atualizar documentação
  • Limpar código auxiliar não utilizado

ObserveFoxit PDF SDK e Foxit são marcas registradas da Foxit Software Incorporated. Este site não é afiliado, endossado ou patrocinado pela Foxit Software. 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