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 de aspose.pdf para ironpdf
GUIAS DE MIGRAçãO

Como migrar do Aspose.PDF para o IronPDF em C#

Curtis Chau
Curtis Chau
Publicado:

Full Comparison

Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against Aspose PDF on pricing, HTML support, and licensing.

View Full Comparison

Por que migrar do Aspose.PDF?

Embora o Aspose.PDF ofereça funcionalidades de nível empresarial, diversos fatores levam as equipes de desenvolvimento a buscar alternativas modernas para suas necessidades de geração de PDFs.

Comparação de custos

Aspose.PDF usa um modelo de licença perpétua que inclui um ano de atualizações; a renovação opcional estende a janela de atualizações. Fonte: página de preços da Aspose.

Aspecto Aspose.PDF IronPDF
Preço Inicial (Pequena Empresa Desenvolvedora) $1.199/desenvolvedor $749 (pagamento único) (Lite)
Modelo de Licença Perpétua + 1 ano de atualizações; optional renewal Licença perpétua
Developer OEM $3.597/desenvolvedor (implantações ilimitadas) Incluído nos níveis superiores
Apoiar Incluído em todos os níveis pagos Incluído
Avaliação Gratuita Licença temporária de 30 dias (caso contrário, marcas d'água + limites de tamanho) Grátis para desenvolvimento

Comparação de mecanismos de renderização HTML

Aspose.PDF usa um mecanismo de renderização HTML/CSS interno (não Chromium); relatórios de usuários no fórum Aspose observam lacunas com recursos modernos de layout CSS, como Flexbox e CSS Grid. O IronPDF usa uma versão incorporada do Chromium para renderização HTML-to-PDF.

Recurso Aspose.PDF (mecanismo interno) IronPDF (Chromium)
Suporte a CSS3 Parcial; lacunas em recursos modernos de layout CSS3 completo
Flexbox/Grade Limitado / inconsistente (segundo relatórios do fórum Aspose) Suporte total
JavaScript Limitado Suporte completo (V8 via Chromium)
Fontes da Web Parcial Completo
HTML5 moderno Parcial Completo
Qualidade de renderização Variável em layouts complexos Equivalente ao Chrome

Características de Desempenho

Usuários relataram diferenças de desempenho no fórum de suporte Aspose. Os números abaixo refletem cenários relatados pela comunidade — verifique em sua própria carga de trabalho.

Métrica Aspose.PDF IronPDF
Renderização HTML Desacelerações relatadas por usuários em cargas de trabalho complexas de CSS Motor Chromium otimizado
Documentos grandes Crescimento de memória relatado em alguns cenários Streaming eficiente
Desempenho do Linux Alto crescimento de CPU e memória relatado no fórum da comunidade Estável

Aspose.PDF vs. IronPDF: Principais diferenças

Aspecto Aspose.PDF IronPDF
Preços (entrada) $1.199/desenvolvedor (perpétua + 1 ano de atualizações) $749 (pagamento único) (Lite)
Motor HTML Mecanismo interno (CSS moderno limitado) Chromium (CSS3/JS completo)
Desempenho Desacelerações relatadas no fórum em CSS complexo Otimizado
Modelo de Licença Perpétuo + .lic file; renovação opcional para atualizações Chave perpétua + baseada em código
Suporte para Linux Relatos no fórum de problemas de CPU/memória Estável
Indexação de páginas Baseado em 1 (Pages[1]) Baseado em 0 (Pages[0])

Preparação pré-migratória

Pré-requisitos

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

  • .NET Framework 4.6.2 ou superior ou .NET Core 3.1 / .NET 5-9
  • 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 Aspose.PDF

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

# Find all Aspose.Pdf using statements
grep -r "using Aspose.Pdf" --include="*.cs" .

# Find HtmlLoadOptions usage
grep -r "HtmlLoadOptions\|HtmlFragment" --include="*.cs" .

# Find Facades usage
grep -r "PdfFileEditor\|PdfFileMend\|PdfFileStamp" --include="*.cs" .

# Find TextAbsorber usage
grep -r "TextAbsorber\|TextFragmentAbsorber" --include="*.cs" .
# Find all Aspose.Pdf using statements
grep -r "using Aspose.Pdf" --include="*.cs" .

# Find HtmlLoadOptions usage
grep -r "HtmlLoadOptions\|HtmlFragment" --include="*.cs" .

# Find Facades usage
grep -r "PdfFileEditor\|PdfFileMend\|PdfFileStamp" --include="*.cs" .

# Find TextAbsorber usage
grep -r "TextAbsorber\|TextFragmentAbsorber" --include="*.cs" .
SHELL

Mudanças significativas a serem previstas

Padrão Aspose.PDF Alteração necessária
new Document() + Pages.Add() Use a renderização HTML em vez disso.
HtmlLoadOptions ChromePdfRenderer.RenderHtmlAsPdf()
TextFragment + posicionamento manual Posicionamento baseado em CSS
PdfFileEditor.Concatenate() PdfDocument.Merge()
TextFragmentAbsorber pdf.ExtractAllText()
ImageStamp Marcas d'água baseadas em HTML
Licenciamento de arquivo .lic Chave de licença baseada em código
indexação de páginas baseada em 1 indexação de páginas baseada em 0

Processo de migração passo a passo

Passo 1: Atualizar pacotes NuGet

Remova o Aspose.PDF e instale o IronPDF:

# Remove Aspose.PDF
dotnet remove package Aspose.PDF

# Install IronPDF
dotnet add package IronPdf
# Remove Aspose.PDF
dotnet remove package Aspose.PDF

# Install IronPDF
dotnet add package IronPdf
SHELL

Ou através do Console do Gerenciador de Pacotes:

Uninstall-Package Aspose.PDF
Install-Package IronPdf

Etapa 2: Atualizar referências de namespace

Substitua os namespaces do Aspose.PDF pelo IronPDF:

// Remove these
using Aspose.Pdf;
using Aspose.Pdf.Text;
using Aspose.Pdf.Facades;
using Aspose.Pdf.Generator;

// Add these
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;
// Remove these
using Aspose.Pdf;
using Aspose.Pdf.Text;
using Aspose.Pdf.Facades;
using Aspose.Pdf.Generator;

// Add these
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;
' Remove these
' Imports Aspose.Pdf
' Imports Aspose.Pdf.Text
' Imports Aspose.Pdf.Facades
' Imports Aspose.Pdf.Generator

' Add these
Imports IronPdf
Imports IronPdf.Rendering
Imports IronPdf.Editing
$vbLabelText   $csharpLabel

Etapa 3: Atualizar a configuração da licença

O Aspose.PDF utiliza licenciamento por arquivo .lic. O IronPDF utiliza uma chave simples baseada em código.

Implementação do Aspose.PDF:

var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.Pdf.lic");
var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.Pdf.lic");
Imports Aspose.Pdf

Dim license As New License()
license.SetLicense("Aspose.Pdf.lic")
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

Referência completa para migração de API

Mapeamento de Classes Principais

Classe Aspose.PDF Equivalente ao IronPDF
Document PdfDocument
HtmlLoadOptions ChromePdfRenderer
TextFragmentAbsorber PdfDocument.ExtractAllText()
PdfFileEditor PdfDocument.Merge()
TextStamp / ImageStamp PdfDocument.ApplyWatermark()
License IronPdf.License

Operações de Documentos

Método Aspose.PDF Método IronPDF
new Document() new PdfDocument()
new Document(path) PdfDocument.FromFile(path)
doc.Save(path) pdf.SaveAs(path)
doc.Pages.Count pdf.PageCount
doc.Pages.Delete(index) pdf.RemovePages(index)

Conversão de HTML para PDF

Método Aspose.PDF Método IronPDF
new HtmlLoadOptions() new ChromePdfRenderer()
new Document(stream, htmlOptions) renderer.RenderHtmlAsPdf(html)
new Document(path, htmlOptions) renderer.RenderHtmlFileAsPdf(path)

Exemplos de migração de código

String HTML para PDF

A operação mais comum do Aspose.PDF demonstra a diferença fundamental de abordagem: o Aspose.PDF exige que o HTML seja encapsulado em um MemoryStream, enquanto o IronPDF aceita strings diretamente.

Implementação do Aspose.PDF:

// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>";

        using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(htmlContent)))
        {
            var htmlLoadOptions = new HtmlLoadOptions();
            var document = new Document(stream, htmlLoadOptions);
            document.Save("output.pdf");
        }

        Console.WriteLine("PDF created from HTML string");
    }
}
// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>";

        using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(htmlContent)))
        {
            var htmlLoadOptions = new HtmlLoadOptions();
            var document = new Document(stream, htmlLoadOptions);
            document.Save("output.pdf");
        }

        Console.WriteLine("PDF created from HTML string");
    }
}
Imports Aspose.Pdf
Imports System
Imports System.IO
Imports System.Text

Module Program
    Sub Main()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>"

        Using stream As New MemoryStream(Encoding.UTF8.GetBytes(htmlContent))
            Dim htmlLoadOptions As New HtmlLoadOptions()
            Dim document As New Document(stream, htmlLoadOptions)
            document.Save("output.pdf")
        End Using

        Console.WriteLine("PDF created from HTML string")
    End Sub
End Module
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

class Program
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created from HTML string");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created from HTML string");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML string.</p></body></html>"

        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created from HTML string")
    End Sub
End Class
$vbLabelText   $csharpLabel

O IronPDF elimina completamente o wrapper MemoryStream, resultando em uma API mais limpa e intuitiva.

Arquivo HTML para PDF

Implementação do Aspose.PDF:

// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;

class Program
{
    static void Main()
    {
        var htmlLoadOptions = new HtmlLoadOptions();
        var document = new Document("input.html", htmlLoadOptions);
        document.Save("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;

class Program
{
    static void Main()
    {
        var htmlLoadOptions = new HtmlLoadOptions();
        var document = new Document("input.html", htmlLoadOptions);
        document.Save("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports Aspose.Pdf
Imports System

Class Program
    Shared Sub Main()
        Dim htmlLoadOptions As New HtmlLoadOptions()
        Dim document As New Document("input.html", htmlLoadOptions)
        document.Save("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class
$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.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Unir vários PDFs

O Aspose.PDF exige que você percorra as páginas manualmente.IronPDF fornece um método Merge estático.

Implementação do Aspose.PDF:

// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;

class Program
{
    static void Main()
    {
        var document1 = new Document("file1.pdf");
        var document2 = new Document("file2.pdf");

        foreach (Page page in document2.Pages)
        {
            document1.Pages.Add(page);
        }

        document1.Save("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package Aspose.PDF
using Aspose.Pdf;
using System;

class Program
{
    static void Main()
    {
        var document1 = new Document("file1.pdf");
        var document2 = new Document("file2.pdf");

        foreach (Page page in document2.Pages)
        {
            document1.Pages.Add(page);
        }

        document1.Save("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports Aspose.Pdf
Imports System

Class Program
    Shared Sub Main()
        Dim document1 As New Document("file1.pdf")
        Dim document2 As New Document("file2.pdf")

        For Each page As Page In document2.Pages
            document1.Pages.Add(page)
        Next

        document1.Save("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Implementação do IronPDF:

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

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("file1.pdf");
        var pdf2 = PdfDocument.FromFile("file2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("file1.pdf");
        var pdf2 = PdfDocument.FromFile("file2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("file1.pdf")
        Dim pdf2 = PdfDocument.FromFile("file2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")

        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Extração de texto

Implementação do Aspose.PDF:

using Aspose.Pdf;
using Aspose.Pdf.Text;

var document = new Document("document.pdf");
var absorber = new TextAbsorber();

foreach (Page page in document.Pages)
{
    page.Accept(absorber);
}

string extractedText = absorber.Text;
Console.WriteLine(extractedText);
using Aspose.Pdf;
using Aspose.Pdf.Text;

var document = new Document("document.pdf");
var absorber = new TextAbsorber();

foreach (Page page in document.Pages)
{
    page.Accept(absorber);
}

string extractedText = absorber.Text;
Console.WriteLine(extractedText);
Imports Aspose.Pdf
Imports Aspose.Pdf.Text

Dim document As New Document("document.pdf")
Dim absorber As New TextAbsorber()

For Each page As Page In document.Pages
    page.Accept(absorber)
Next

Dim extractedText As String = absorber.Text
Console.WriteLine(extractedText)
$vbLabelText   $csharpLabel

Implementação do IronPDF:

using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text - one line!
string allText = pdf.ExtractAllText();
Console.WriteLine(allText);

// Or extract from specific page
string page1Text = pdf.ExtractTextFromPage(0);
using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text - one line!
string allText = pdf.ExtractAllText();
Console.WriteLine(allText);

// Or extract from specific page
string page1Text = pdf.ExtractTextFromPage(0);
Imports IronPdf

Dim pdf = PdfDocument.FromFile("document.pdf")

' Extract all text - one line!
Dim allText As String = pdf.ExtractAllText()
Console.WriteLine(allText)

' Or extract from specific page
Dim page1Text As String = pdf.ExtractTextFromPage(0)
$vbLabelText   $csharpLabel

O IronPDF simplifica a extração de texto, reduzindo-a de várias etapas para uma única chamada de método.

Adicionando marcas d'água

Implementação do Aspose.PDF:

using Aspose.Pdf;
using Aspose.Pdf.Text;

var document = new Document("document.pdf");

var textStamp = new TextStamp("CONFIDENTIAL");
textStamp.Background = true;
textStamp.XIndent = 100;
textStamp.YIndent = 100;
textStamp.Rotate = Rotation.on45;
textStamp.Opacity = 0.5;
textStamp.TextState.Font = FontRepository.FindFont("Arial");
textStamp.TextState.FontSize = 72;
textStamp.TextState.ForegroundColor = Color.Red;

foreach (Page page in document.Pages)
{
    page.AddStamp(textStamp);
}

document.Save("watermarked.pdf");
using Aspose.Pdf;
using Aspose.Pdf.Text;

var document = new Document("document.pdf");

var textStamp = new TextStamp("CONFIDENTIAL");
textStamp.Background = true;
textStamp.XIndent = 100;
textStamp.YIndent = 100;
textStamp.Rotate = Rotation.on45;
textStamp.Opacity = 0.5;
textStamp.TextState.Font = FontRepository.FindFont("Arial");
textStamp.TextState.FontSize = 72;
textStamp.TextState.ForegroundColor = Color.Red;

foreach (Page page in document.Pages)
{
    page.AddStamp(textStamp);
}

document.Save("watermarked.pdf");
Imports Aspose.Pdf
Imports Aspose.Pdf.Text

Dim document As New Document("document.pdf")

Dim textStamp As New TextStamp("CONFIDENTIAL")
textStamp.Background = True
textStamp.XIndent = 100
textStamp.YIndent = 100
textStamp.Rotate = Rotation.on45
textStamp.Opacity = 0.5
textStamp.TextState.Font = FontRepository.FindFont("Arial")
textStamp.TextState.FontSize = 72
textStamp.TextState.ForegroundColor = Color.Red

For Each page As Page In document.Pages
    page.AddStamp(textStamp)
Next

document.Save("watermarked.pdf")
$vbLabelText   $csharpLabel

Implementação do IronPDF:

using IronPdf;
using IronPdf.Editing;

var pdf = PdfDocument.FromFile("document.pdf");

// HTML-based watermark with full styling control
string watermarkHtml = @"
<div style='
    color: red;
    opacity: 0.5;
    font-family: Arial;
    font-size: 72px;
    font-weight: bold;
    text-align: center;
'>CONFIDENTIAL</div>";

pdf.ApplyWatermark(watermarkHtml,
    rotation: 45,
    verticalAlignment: VerticalAlignment.Middle,
    horizontalAlignment: HorizontalAlignment.Center);

pdf.SaveAs("watermarked.pdf");
using IronPdf;
using IronPdf.Editing;

var pdf = PdfDocument.FromFile("document.pdf");

// HTML-based watermark with full styling control
string watermarkHtml = @"
<div style='
    color: red;
    opacity: 0.5;
    font-family: Arial;
    font-size: 72px;
    font-weight: bold;
    text-align: center;
'>CONFIDENTIAL</div>";

pdf.ApplyWatermark(watermarkHtml,
    rotation: 45,
    verticalAlignment: VerticalAlignment.Middle,
    horizontalAlignment: HorizontalAlignment.Center);

pdf.SaveAs("watermarked.pdf");
Imports IronPdf
Imports IronPdf.Editing

Dim pdf = PdfDocument.FromFile("document.pdf")

' HTML-based watermark with full styling control
Dim watermarkHtml As String = "
<div style='
    color: red;
    opacity: 0.5;
    font-family: Arial;
    font-size: 72px;
    font-weight: bold;
    text-align: center;
'>CONFIDENTIAL</div>"

pdf.ApplyWatermark(watermarkHtml,
    rotation:=45,
    verticalAlignment:=VerticalAlignment.Middle,
    horizontalAlignment:=HorizontalAlignment.Center)

pdf.SaveAs("watermarked.pdf")
$vbLabelText   $csharpLabel

O IronPDF utiliza marcas d'água baseadas em HTML/CSS , proporcionando controle total sobre o estilo através de tecnologias web já conhecidas.

Proteção por senha

Implementação do Aspose.PDF:

using Aspose.Pdf;

var document = new Document("document.pdf");
document.Encrypt("userPassword", "ownerPassword", DocumentPrivilege.ForbidAll, CryptoAlgorithm.AESx256);
document.Save("protected.pdf");
using Aspose.Pdf;

var document = new Document("document.pdf");
document.Encrypt("userPassword", "ownerPassword", DocumentPrivilege.ForbidAll, CryptoAlgorithm.AESx256);
document.Save("protected.pdf");
Imports Aspose.Pdf

Dim document As New Document("document.pdf")
document.Encrypt("userPassword", "ownerPassword", DocumentPrivilege.ForbidAll, CryptoAlgorithm.AESx256)
document.Save("protected.pdf")
$vbLabelText   $csharpLabel

Implementação do IronPDF:

using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Set passwords
pdf.SecuritySettings.UserPassword = "userPassword";
pdf.SecuritySettings.OwnerPassword = "ownerPassword";

// Set permissions
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Set passwords
pdf.SecuritySettings.UserPassword = "userPassword";
pdf.SecuritySettings.OwnerPassword = "ownerPassword";

// Set permissions
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
Imports IronPdf

Dim pdf = PdfDocument.FromFile("document.pdf")

' Set passwords
pdf.SecuritySettings.UserPassword = "userPassword"
pdf.SecuritySettings.OwnerPassword = "ownerPassword"

' Set permissions
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit

pdf.SaveAs("protected.pdf")
$vbLabelText   $csharpLabel

O IronPDF oferece controle granular sobre as permissões por meio de propriedades fortemente tipadas. Para mais opções, consulte a documentação de criptografia .

Cabeçalhos e rodapés

Implementação do IronPDF:

using IronPdf;

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align:center; font-family:Arial; font-size:12px;'>
            Company Header
        </div>",
    DrawDividerLine = true,
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align:center; font-family:Arial; font-size:10px;'>
            Page {page} of {total-pages}
        </div>",
    DrawDividerLine = true,
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content here</h1>");
pdf.SaveAs("with_headers.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align:center; font-family:Arial; font-size:12px;'>
            Company Header
        </div>",
    DrawDividerLine = true,
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align:center; font-family:Arial; font-size:10px;'>
            Page {page} of {total-pages}
        </div>",
    DrawDividerLine = true,
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content here</h1>");
pdf.SaveAs("with_headers.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='text-align:center; font-family:Arial; font-size:12px;'>
            Company Header
        </div>",
    .DrawDividerLine = True,
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='text-align:center; font-family:Arial; font-size:10px;'>
            Page {page} of {total-pages}
        </div>",
    .DrawDividerLine = True,
    .MaxHeight = 25
}

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Content here</h1>")
pdf.SaveAs("with_headers.pdf")
$vbLabelText   $csharpLabel

IronPDF suporta tokens de espaço reservado como {page} e {total-pages} para numeração dinâmica de páginas. Para mais opções, consulte a documentação sobre cabeçalhos e rodapés .

Notas críticas sobre migração

Alteração na indexação da página

O Aspose.PDF utiliza indexação baseada em 1. O IronPDF utiliza indexação baseada em zero:

// Aspose.PDF - 1-based indexing
var firstPage = doc.Pages[1];  // First page
var thirdPage = doc.Pages[3];  // Third page

//IronPDF- 0-based indexing
var firstPage = pdf.Pages[0];  // First page
var thirdPage = pdf.Pages[2];  // Third page
// Aspose.PDF - 1-based indexing
var firstPage = doc.Pages[1];  // First page
var thirdPage = doc.Pages[3];  // Third page

//IronPDF- 0-based indexing
var firstPage = pdf.Pages[0];  // First page
var thirdPage = pdf.Pages[2];  // Third page
Imports Aspose.Pdf
Imports IronPdf

' Aspose.PDF - 1-based indexing
Dim firstPageAspose = doc.Pages(1)  ' First page
Dim thirdPageAspose = doc.Pages(3)  ' Third page

' IronPDF - 0-based indexing
Dim firstPageIron = pdf.Pages(0)  ' First page
Dim thirdPageIron = pdf.Pages(2)  ' Third page
$vbLabelText   $csharpLabel

Arquivo de licença para chave de código

Substitua o licenciamento de arquivo .lic por ativação baseada em código:

// Aspose.PDF
var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.Pdf.lic");

// IronPDF
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Or from environment variable
IronPdf.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY");
// Aspose.PDF
var license = new Aspose.Pdf.License();
license.SetLicense("Aspose.Pdf.lic");

// IronPDF
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Or from environment variable
IronPdf.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY");
Imports Aspose.Pdf
Imports System

Dim license As New License()
license.SetLicense("Aspose.Pdf.lic")

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Or from environment variable
IronPdf.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE_KEY")
$vbLabelText   $csharpLabel

Integração com ASP.NET Core

Padrão IronPDF:

[ApiController]
[Route("[controller]")]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }
}
[ApiController]
[Route("[controller]")]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }
}
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class PdfController
    Inherits ControllerBase

    <HttpGet("generate")>
    Public Function GeneratePdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>")

        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Function

    <HttpGet("generate-async")>
    Public Async Function GeneratePdfAsync() As Task(Of IActionResult)
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>")

        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Configuração de Injeção de Dependência

// Program.cs
public void ConfigureServices(IServiceCollection services)
{
    // Set license once
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];

    // Register renderer as scoped service
    services.AddScoped<ChromePdfRenderer>();
}
// Program.cs
public void ConfigureServices(IServiceCollection services)
{
    // Set license once
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];

    // Register renderer as scoped service
    services.AddScoped<ChromePdfRenderer>();
}
' Program.vb
Public Sub ConfigureServices(services As IServiceCollection)
    ' Set license once
    IronPdf.License.LicenseKey = Configuration("IronPdf:LicenseKey")

    ' Register renderer as scoped service
    services.AddScoped(Of ChromePdfRenderer)()
End Sub
$vbLabelText   $csharpLabel

Otimização de desempenho

// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

// 2. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
renderer.RenderingOptions.Timeout = 30000;          // 30s max

// 3. Proper disposal
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
}
// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

// 2. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
renderer.RenderingOptions.Timeout = 30000;          // 30s max

// 3. Proper disposal
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
}
' 1. Reuse renderer instance
Private Shared ReadOnly SharedRenderer As New ChromePdfRenderer()

' 2. Disable unnecessary features for speed
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = False ' If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0)   ' No delay
renderer.RenderingOptions.Timeout = 30000          ' 30s max

' 3. Proper disposal
Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
End Using
$vbLabelText   $csharpLabel

Solução de problemas comuns de migração

Problema: HtmlLoadOptions não encontrado

Substitua por ChromePdfRenderer:

// Remove this
var doc = new Document(stream, new HtmlLoadOptions());

// Use this
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlString);
// Remove this
var doc = new Document(stream, new HtmlLoadOptions());

// Use this
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlString);
Dim doc = New Document(stream, New HtmlLoadOptions())

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlString)
$vbLabelText   $csharpLabel

Problema: Absorvedor de Fragmentos de Texto Não Encontrado

Utilizar extração direta de texto:

// Remove this
var absorber = new TextFragmentAbsorber();
page.Accept(absorber);
string text = absorber.Text;

// Use this
var pdf = PdfDocument.FromFile("doc.pdf");
string text = pdf.ExtractAllText();
// Remove this
var absorber = new TextFragmentAbsorber();
page.Accept(absorber);
string text = absorber.Text;

// Use this
var pdf = PdfDocument.FromFile("doc.pdf");
string text = pdf.ExtractAllText();
' Remove this
Dim absorber As New TextFragmentAbsorber()
page.Accept(absorber)
Dim text As String = absorber.Text

' Use this
Dim pdf = PdfDocument.FromFile("doc.pdf")
Dim text As String = pdf.ExtractAllText()
$vbLabelText   $csharpLabel

Problema: PdfFileEditor.Concatenate não disponível

Use PdfDocument.Merge():

// Remove this
var editor = new PdfFileEditor();
editor.Concatenate(files, output);

// Use this
var pdfs = files.Select(PdfDocument.FromFile).ToList();
var merged = PdfDocument.Merge(pdfs);
merged.SaveAs(output);
// Remove this
var editor = new PdfFileEditor();
editor.Concatenate(files, output);

// Use this
var pdfs = files.Select(PdfDocument.FromFile).ToList();
var merged = PdfDocument.Merge(pdfs);
merged.SaveAs(output);
' Remove this
Dim editor = New PdfFileEditor()
editor.Concatenate(files, output)

' Use this
Dim pdfs = files.Select(Function(file) PdfDocument.FromFile(file)).ToList()
Dim merged = PdfDocument.Merge(pdfs)
merged.SaveAs(output)
$vbLabelText   $csharpLabel

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

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

  • Remover arquivos de licença do Aspose.PDF (.lic)
  • Verificar a qualidade da renderização HTML (CSS Grid e Flexbox agora devem funcionar corretamente)
  • Testar casos extremos com documentos grandes e CSS complexo.
  • Atualizar referências do índice da página (baseado em 1 para baseado em 0)
  • Atualize as configurações do Docker, se aplicável.
  • Atualizar pipelines de CI/CD com a nova configuração de chave de licença
  • Documente novos padrões para sua equipe

Recursos adicionais

Migrar de Aspose.PDF para IronPDF move sua base de código de um mecanismo HTML interno para renderização baseada em Chromium. A eliminação dos wrappers MemoryStream, a simplificação da extração de texto e o suporte mais amplo ao CSS3 proporcionam ganhos imediatos de produtividade, e a chave baseada em código do IronPDF substitui o manuseio de arquivos .lic.

ObserveAspose é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pela Aspose Pty Ltd. 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