GUIAS DE MIGRAçãO

Como migrar do Nutrient.io para o IronPDF em C#

Atualizado:fevereiro 1, 2026

A migração do Nutrient.io (anteriormente PSPDFKit) para o IronPDF simplifica seu fluxo de trabalho de PDF em .NET , passando de uma plataforma complexa de inteligência de documentos com padrões assíncronos para uma biblioteca de PDF focada com APIs síncronas diretas. Este guia fornece um caminho de migração abrangente, passo a passo, que elimina a sobrecarga da plataforma, mantendo todos os recursos essenciais de PDF.

Por que migrar do Nutrient.io para o IronPDF?

O Problema da Complexidade da Plataforma

O Nutrient.io (anteriormente PSPDFKit) evoluiu de um SDK de PDF para uma plataforma abrangente de "inteligência de documentos". Embora essa transformação amplie as capacidades, ela introduz desafios significativos para equipes que simplesmente precisam de operações confiáveis com PDFs:

Superdimensionamento da plataforma: O que antes era um SDK de PDF agora é uma plataforma completa de inteligência de documentos com recursos de IA e capacidades de fluxo de trabalho de documentos que podem ser desnecessárias para tarefas simples em PDF.
Preços para Empresas: A Nutrient.io está posicionada para grandes organizações com preços pouco transparentes que exigem contato com a equipe de vendas. Isso cria barreiras para equipes de pequeno a médio porte e dificulta o planejamento orçamentário.
Confusão com a mudança de marca: A transição de PSPDFKit para Nutrient gerou problemas de documentação, com referências a ambos os nomes. Os nomes dos pacotes ainda podem usar PSPDFKit, e os caminhos de migração durante a transição permanecem obscuros.
Complexidade Assíncrona: Tudo no Nutrient.io requer padrões async/await. Mesmo operações simples precisam de PdfProcessor.CreateAsync() para inicialização e métodos assíncronos para tarefas básicas, adicionando sobrecarga para fluxos de trabalho síncronos.
Dependências complexas: A plataforma completa requer mais recursos, com um tamanho de pacote maior, mais tempo de inicialização e configuração adicional.

Comparação entre Nutrient.io e IronPDF

Aspecto	Nutrient.io (PSPDFKit)	IronPDF
Foco	Plataforma de inteligência de documentos	Biblioteca de PDFs
Preços	Empresa (contato com a equipe de vendas)	Transparente, publicado
Arquitetura	Plataforma complexa	Biblioteca simples
Estilo API	Assíncrono primeiro	Sincronizar com opções assíncronas
Dependências	Pesado	Leve
Configuração	Objetos de configuração complexos	Propriedades simples
Curva de Aprendizagem	Íngreme (plataforma)	Suave (biblioteca)
Usuários-alvo	Empresa	Todos os tamanhos de equipe

Para equipes que planejam a adoção do .NET 10 e do C# 14 até 2025 e 2026, o IronPDF oferece uma base mais simples que se integra perfeitamente, sem a sobrecarga de uma plataforma completa de inteligência de documentos.

Antes de começar

Pré-requisitos

Ambiente .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
Acesso ao NuGet : Capacidade de instalar pacotes NuGet.
Licença do IronPDF : Obtenha sua chave de licença em IronPDF

Alterações no pacote NuGet

# Remove Nutrient/PSPDFKit packages
dotnet remove package PSPDFKit.NET
dotnet remove package PSPDFKit.PDF
dotnet remove package Nutrient
dotnet remove package Nutrient.PDF

# Install IronPDF
dotnet add package IronPdf

# Remove Nutrient/PSPDFKit packages
dotnet remove package PSPDFKit.NET
dotnet remove package PSPDFKit.PDF
dotnet remove package Nutrient
dotnet remove package Nutrient.PDF

# Install IronPDF
dotnet add package IronPdf

SHELL

Configuração de licença

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Identificar o uso do Nutrient.io

# Find all Nutrient/PSPDFKit references
grep -r "PSPDFKit\|Nutrient\|PdfProcessor\|PdfConfiguration" --include="*.cs" .

# Find all Nutrient/PSPDFKit references
grep -r "PSPDFKit\|Nutrient\|PdfProcessor\|PdfConfiguration" --include="*.cs" .

SHELL

Referência completa da API

Mapeamentos de inicialização

Nutrient.io (PSPDFKit)	IronPDF
`await PdfProcessor.CreateAsync()`	`new ChromePdfRenderer()`
`processor.Dispose()`	(automático ou manual)
`new PdfConfiguration { ... }`	`renderer.RenderingOptions`

Mapeamentos de carregamento de documentos

Nutrient.io (PSPDFKit)	IronPDF
`await processor.OpenAsync(path)`	`PdfDocument.FromFile(path)`
`Document.LoadFromStream(stream)`	`PdfDocument.FromStream(stream)`
`Document.LoadFromBytes(bytes)`	`new PdfDocument(bytes)`

Mapeamentos de geração de PDF

Nutrient.io (PSPDFKit)	IronPDF
`await processor.GeneratePdfFromHtmlStringAsync(html)`	`renderer.RenderHtmlAsPdf(html)`
`await processor.GeneratePdfFromUrlAsync(url)`	`renderer.RenderUrlAsPdf(url)`
`await processor.GeneratePdfFromFileAsync(path)`	`renderer.RenderHtmlFileAsPdf(path)`

Mapeamentos de operações de documentos

Nutrient.io (PSPDFKit)	IronPDF
`await processor.MergeAsync(docs)`	`PdfDocument.Merge(pdfs)`
`document.PageCount`	`pdf.PageCount`
`await document.SaveAsync(path)`	`pdf.SaveAs(path)`
`document.ToBytes()`	`pdf.BinaryData`

Mapeamento de anotações e marcas d'água

Nutrient.io (PSPDFKit)	IronPDF
`await document.AddAnnotationAsync(index, annotation)`	`pdf.ApplyWatermark(html)`
`new TextAnnotation("text")`	HTML na marca d'água
`annotation.Opacity = 0.5`	CSS `opacity: 0.5`
`annotation.FontSize = 48`	CSS `font-size: 48px`

Exemplos de migração de código

Exemplo 1: Conversão de HTML para PDF

Antes (Nutrient.io):

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.GeneratePdfFromHtmlStringAsync(htmlContent);
        await document.SaveAsync("output.pdf");
    }
}

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.GeneratePdfFromHtmlStringAsync(htmlContent);
        await document.SaveAsync("output.pdf");
    }
}

Imports PSPDFKit.Pdf
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        Using processor = Await PdfProcessor.CreateAsync()
            Dim document = Await processor.GeneratePdfFromHtmlStringAsync(htmlContent)
            Await document.SaveAsync("output.pdf")
        End Using
    End Function
End Module

$vbLabelText $csharpLabel

Após (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

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

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

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

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

A abordagem Nutrient.io requer várias etapas assíncronas: criar um PdfProcessor com await PdfProcessor.CreateAsync(), depois chamar await processor.GeneratePdfFromHtmlStringAsync() e, finalmente, await document.SaveAsync(). Todo o método deve ser marcado com async Task, e o processador requer uma declaração using para descarte adequado.

O IronPDF simplifica isso drasticamente. Crie um ChromePdfRenderer, chame RenderHtmlAsPdf() e salve com SaveAs(). Não é necessário async/await, não há ciclo de vida do processador para gerenciar e não são necessários blocos using para operações simples. Esse padrão é mais intuitivo para desenvolvedores que não precisam de padrões assíncronos em seu fluxo de trabalho com PDFs. Consulte a documentação de conversão de HTML para PDF para obter opções de renderização adicionais.

Exemplo 2: Mesclar vários PDFs

Antes (Nutrient.io):

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();

        var document1 = await processor.OpenAsync("document1.pdf");
        var document2 = await processor.OpenAsync("document2.pdf");

        var mergedDocument = await processor.MergeAsync(new List<PdfDocument> { document1, document2 });
        await mergedDocument.SaveAsync("merged.pdf");
    }
}

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();

        var document1 = await processor.OpenAsync("document1.pdf");
        var document2 = await processor.OpenAsync("document2.pdf");

        var mergedDocument = await processor.MergeAsync(new List<PdfDocument> { document1, document2 });
        await mergedDocument.SaveAsync("merged.pdf");
    }
}

Imports PSPDFKit.Pdf
Imports System.Threading.Tasks
Imports System.Collections.Generic

Class Program
    Shared Async Function Main() As Task
        Using processor = Await PdfProcessor.CreateAsync()

            Dim document1 = Await processor.OpenAsync("document1.pdf")
            Dim document2 = Await processor.OpenAsync("document2.pdf")

            Dim mergedDocument = Await processor.MergeAsync(New List(Of PdfDocument) From {document1, document2})
            Await mergedDocument.SaveAsync("merged.pdf")
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

Após (IronPDF):

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

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

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

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

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

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

Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

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

$vbLabelText $csharpLabel

A operação de mesclagem do Nutrient.io requer a criação de um processador com await PdfProcessor.CreateAsync(), a abertura de cada documento com chamadas separadas de await processor.OpenAsync(), a criação de um List<PdfDocument>, a chamada de await processor.MergeAsync() com essa lista e, finalmente, await mergedDocument.SaveAsync(). São cinco operações assíncronas para uma mesclagem básica.

O IronPDF reduz isso a quatro linhas síncronas: carregar cada PDF com PdfDocument.FromFile(), mesclar com o método estático PdfDocument.Merge() e salvar. Sem ciclo de vida do processador, sem necessidade de criação de listas (você pode passar documentos diretamente) e sem sobrecarga assíncrona. Saiba mais sobre como mesclar e dividir PDFs .

Exemplo 3: Adicionando marcas d'água

Antes (Nutrient.io):

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using PSPDFKit.Pdf.Annotation;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.OpenAsync("document.pdf");

        for (int i = 0; i < document.PageCount; i++)
        {
            var watermark = new TextAnnotation("CONFIDENTIAL")
            {
                Opacity = 0.5,
                FontSize = 48
            };
            await document.AddAnnotationAsync(i, watermark);
        }

        await document.SaveAsync("watermarked.pdf");
    }
}

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using PSPDFKit.Pdf.Annotation;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.OpenAsync("document.pdf");

        for (int i = 0; i < document.PageCount; i++)
        {
            var watermark = new TextAnnotation("CONFIDENTIAL")
            {
                Opacity = 0.5,
                FontSize = 48
            };
            await document.AddAnnotationAsync(i, watermark);
        }

        await document.SaveAsync("watermarked.pdf");
    }
}

Imports PSPDFKit.Pdf
Imports PSPDFKit.Pdf.Annotation
Imports System.Threading.Tasks

Class Program
    Shared Async Function Main() As Task
        Using processor = Await PdfProcessor.CreateAsync()
            Dim document = Await processor.OpenAsync("document.pdf")

            For i As Integer = 0 To document.PageCount - 1
                Dim watermark = New TextAnnotation("CONFIDENTIAL") With {
                    .Opacity = 0.5,
                    .FontSize = 48
                }
                Await document.AddAnnotationAsync(i, watermark)
            Next

            Await document.SaveAsync("watermarked.pdf")
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

Após (IronPDF):

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

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

        pdf.ApplyWatermark("<h1 style='color:gray;opacity:0.5;'>CONFIDENTIAL</h1>",
            50,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}

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

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

        pdf.ApplyWatermark("<h1 style='color:gray;opacity:0.5;'>CONFIDENTIAL</h1>",
            50,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Editing

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

        pdf.ApplyWatermark("<h1 style='color:gray;opacity:0.5;'>CONFIDENTIAL</h1>", 
                           50, 
                           VerticalAlignment.Middle, 
                           HorizontalAlignment.Center)

        pdf.SaveAs("watermarked.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

Este exemplo destaca uma diferença arquitetônica fundamental. O Nutrient.io usa uma abordagem baseada em anotações: você cria um objeto TextAnnotation com propriedades como Opacity e FontSize, e então percorre cada página chamando await document.AddAnnotationAsync(i, watermark) para cada uma delas. Isso exige compreender o sistema de anotações e gerenciar o loop por conta própria.

O IronPDF usa uma abordagem baseada em HTML: o método ApplyWatermark() aceita uma string HTML com estilo CSS. A marca d'água é aplicada automaticamente a todas as páginas em uma única chamada. Você controla a aparência por meio de propriedades CSS familiares (color, opacity, font-size) em vez de propriedades de objeto específicas da anotação. Essa abordagem oferece mais flexibilidade de estilo — você pode usar qualquer HTML/CSS, incluindo gradientes, imagens e layouts complexos. Consulte a documentação da marca d'água para exemplos avançados.

Notas críticas sobre migração

Conversão de assíncrono para síncrono

A mudança mais significativa é a remoção de padrões async/await desnecessários:

// Nutrient.io: Async-first
using var processor = await PdfProcessor.CreateAsync();
var document = await processor.GeneratePdfFromHtmlStringAsync(html);
await document.SaveAsync("output.pdf");

// IronPDF: Sync by default (async available when needed)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Nutrient.io: Async-first
using var processor = await PdfProcessor.CreateAsync();
var document = await processor.GeneratePdfFromHtmlStringAsync(html);
await document.SaveAsync("output.pdf");

// IronPDF: Sync by default (async available when needed)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Imports System
Imports System.Threading.Tasks

' Nutrient.io: Async-first
Using processor = Await PdfProcessor.CreateAsync()
    Dim document = Await processor.GeneratePdfFromHtmlStringAsync(html)
    Await document.SaveAsync("output.pdf")
End Using

' IronPDF: Sync by default (async available when needed)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

$vbLabelText $csharpLabel

Se você precisar de operações assíncronas, o IronPDF fornece variantes assíncronas como RenderHtmlAsPdfAsync().

Eliminação do ciclo de vida do processador

O Nutrient.io requer a criação e o descarte de processadores:

// Nutrient.io: Processor lifecycle management
using var processor = await PdfProcessor.CreateAsync();
// ... use processor ...
// Processor disposed at end of using block

// IronPDF: No processor lifecycle
var renderer = new ChromePdfRenderer();
// Reuse renderer, no complex lifecycle management

// Nutrient.io: Processor lifecycle management
using var processor = await PdfProcessor.CreateAsync();
// ... use processor ...
// Processor disposed at end of using block

// IronPDF: No processor lifecycle
var renderer = new ChromePdfRenderer();
// Reuse renderer, no complex lifecycle management

Imports IronPdf

' Nutrient.io: Processor lifecycle management
Using processor = Await PdfProcessor.CreateAsync()
    ' ... use processor ...
    ' Processor disposed at end of using block
End Using

' IronPDF: No processor lifecycle
Dim renderer As New ChromePdfRenderer()
' Reuse renderer, no complex lifecycle management

$vbLabelText $csharpLabel

Alteração do padrão de configuração

Nutrient.io utiliza objetos de configuração; O IronPDF utiliza as seguintes propriedades:

// Nutrient.io: Config object
var config = new PdfConfiguration
{
    PageSize = PageSize.A4,
    Margins = new Margins(20, 20, 20, 20)
};
var doc = await processor.GeneratePdfFromHtmlStringAsync(html, config);

// IronPDF: Properties on RenderingOptions
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var pdf = renderer.RenderHtmlAsPdf(html);

// Nutrient.io: Config object
var config = new PdfConfiguration
{
    PageSize = PageSize.A4,
    Margins = new Margins(20, 20, 20, 20)
};
var doc = await processor.GeneratePdfFromHtmlStringAsync(html, config);

// IronPDF: Properties on RenderingOptions
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var pdf = renderer.RenderHtmlAsPdf(html);

Imports System.Threading.Tasks

' Nutrient.io: Config object
Dim config As New PdfConfiguration With {
    .PageSize = PageSize.A4,
    .Margins = New Margins(20, 20, 20, 20)
}
Dim doc = Await processor.GeneratePdfFromHtmlStringAsync(html, config)

' IronPDF: Properties on RenderingOptions
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
Dim pdf = renderer.RenderHtmlAsPdf(html)

$vbLabelText $csharpLabel

Anotação em marcas d'água HTML

Substitua os objetos de anotação por strings HTML:

// Nutrient.io: Annotation object with properties
new TextAnnotation("CONFIDENTIAL") { Opacity = 0.5f, FontSize = 48 }

// IronPDF: HTML with CSS
"<h1 style='opacity:0.5; font-size:48px;'>CONFIDENTIAL</h1>"

// Nutrient.io: Annotation object with properties
new TextAnnotation("CONFIDENTIAL") { Opacity = 0.5f, FontSize = 48 }

// IronPDF: HTML with CSS
"<h1 style='opacity:0.5; font-size:48px;'>CONFIDENTIAL</h1>"

' Nutrient.io: Annotation object with properties
New TextAnnotation("CONFIDENTIAL") With {.Opacity = 0.5F, .FontSize = 48}

' IronPDF: HTML with CSS
"<h1 style='opacity:0.5; font-size:48px;'>CONFIDENTIAL</h1>"

$vbLabelText $csharpLabel

Tratamento de números de página

O Nutrient.io requer contagem manual de páginas; O IronPDF possui marcadores de posição integrados:

// Nutrient.io: Manual loop and page counting
for (int i = 0; i < doc.PageCount; i++)
{
    var footer = new TextAnnotation($"Page {i + 1} of {doc.PageCount}");
    await doc.AddAnnotationAsync(i, footer);
}

// IronPDF: Built-in placeholders
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "Page {page} of {total-pages}"
};

// Nutrient.io: Manual loop and page counting
for (int i = 0; i < doc.PageCount; i++)
{
    var footer = new TextAnnotation($"Page {i + 1} of {doc.PageCount}");
    await doc.AddAnnotationAsync(i, footer);
}

// IronPDF: Built-in placeholders
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "Page {page} of {total-pages}"
};

' Nutrient.io: Manual loop and page counting
For i As Integer = 0 To doc.PageCount - 1
    Dim footer = New TextAnnotation($"Page {i + 1} of {doc.PageCount}")
    Await doc.AddAnnotationAsync(i, footer)
Next

' IronPDF: Built-in placeholders
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "Page {page} of {total-pages}"
}

$vbLabelText $csharpLabel

Solução de problemas

Problema 1: Processador de PDF não encontrado

Problema: a classe PdfProcessor não existe no IronPDF.

Solução: Use ChromePdfRenderer:

// Nutrient.io
using var processor = await PdfProcessor.CreateAsync();

// IronPDF
var renderer = new ChromePdfRenderer();

// Nutrient.io
using var processor = await PdfProcessor.CreateAsync();

// IronPDF
var renderer = new ChromePdfRenderer();

' Nutrient.io
Using processor = Await PdfProcessor.CreateAsync()

' IronPDF
Dim renderer = New ChromePdfRenderer()

$vbLabelText $csharpLabel

Problema 2: GeneratePdfFromHtmlStringAsync não encontrado

Problema: O método HTML assíncrono não existe.

Solução: Use RenderHtmlAsPdf():

// Nutrient.io
var document = await processor.GeneratePdfFromHtmlStringAsync(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

// Nutrient.io
var document = await processor.GeneratePdfFromHtmlStringAsync(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

' Nutrient.io
Dim document = Await processor.GeneratePdfFromHtmlStringAsync(html)

' IronPDF
Dim pdf = renderer.RenderHtmlAsPdf(html)

$vbLabelText $csharpLabel

Problema 3: Anotação de texto não encontrada

Problema: As classes de anotação não existem no IronPDF.

Solução: Utilize marcas d'água baseadas em HTML:

// Nutrient.io
var watermark = new TextAnnotation("DRAFT") { Opacity = 0.5 };
await document.AddAnnotationAsync(0, watermark);

// IronPDF
pdf.ApplyWatermark("<div style='opacity:0.5;'>DRAFT</div>");

// Nutrient.io
var watermark = new TextAnnotation("DRAFT") { Opacity = 0.5 };
await document.AddAnnotationAsync(0, watermark);

// IronPDF
pdf.ApplyWatermark("<div style='opacity:0.5;'>DRAFT</div>");

Imports System.Threading.Tasks

' Nutrient.io
Dim watermark As New TextAnnotation("DRAFT") With {.Opacity = 0.5}
Await document.AddAnnotationAsync(0, watermark)

' IronPDF
pdf.ApplyWatermark("<div style='opacity:0.5;'>DRAFT</div>")

$vbLabelText $csharpLabel

Problema 4: MergeAsync não encontrado

Problema: O método de mesclagem assíncrona não existe.

Solução: Use static PdfDocument.Merge():

// Nutrient.io
var mergedDocument = await processor.MergeAsync(documentList);

// IronPDF
var merged = PdfDocument.Merge(pdf1, pdf2);

// Nutrient.io
var mergedDocument = await processor.MergeAsync(documentList);

// IronPDF
var merged = PdfDocument.Merge(pdf1, pdf2);

Imports System.Threading.Tasks

' Nutrient.io
Dim mergedDocument = Await processor.MergeAsync(documentList)

' IronPDF
Dim merged = PdfDocument.Merge(pdf1, pdf2)

$vbLabelText $csharpLabel

Lista de verificação para migração

Pré-migração

Inventariar todos os usos de PSPDFKit/Nutrient na base de código.
Documentar padrões assíncronos que possam precisar de ajustes.
Liste todos os objetos de configuração e suas propriedades.
Identificar características baseadas em anotações (marcas d'água, cabeçalhos)
Analisar os requisitos de processamento de formulários
Obtenha a chave de licença do IronPDF

Alterações no pacote

Remover o pacote NuGet PSPDFKit.NET
Remover o pacote NuGet Nutrient
Instale o pacote NuGet IronPdf: dotnet add package IronPdf
Atualizar importações de namespace

Alterações no código

Adicionar configuração de chave de licença na inicialização
Substitua PdfProcessor.CreateAsync() por new ChromePdfRenderer()
Substitua processor.GeneratePdfFromHtmlStringAsync() por renderer.RenderHtmlAsPdf()
Substitua processor.MergeAsync() por PdfDocument.Merge()
Converter marcas d'água TextAnnotation em marcas d'água HTML
Substitua os objetos de configuração pelas propriedades RenderingOptions
Atualizar cabeçalho/rodapé para usar HtmlHeaderFooter com marcadores de posição
Remover padrões async/await desnecessários

Pós-migração

Remova async/await onde não for mais necessário.
Execute testes de regressão comparando a saída em PDF.
Verificar se os cabeçalhos/rodapés correspondem aos números de página.
Teste de renderização de marca d'água
Atualizar o pipeline de CI/CD

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

Destaque do cliente:

Destaque do desenvolvedor:

Webinários:

Experimente gratuitamente por 30 dias.

Como migrar do Nutrient.io para o IronPDF em C#

Por que migrar do Nutrient.io para o IronPDF?

O Problema da Complexidade da Plataforma

Comparação entre Nutrient.io e IronPDF

Antes de começar

Pré-requisitos

Alterações no pacote NuGet

Configuração de licença

Identificar o uso do Nutrient.io

Referência completa da API

Mapeamentos de inicialização

Mapeamentos de carregamento de documentos

Mapeamentos de geração de PDF

Mapeamentos de operações de documentos

Mapeamento de anotações e marcas d'água

Exemplos de migração de código

Exemplo 1: Conversão de HTML para PDF

Exemplo 2: Mesclar vários PDFs

Exemplo 3: Adicionando marcas d'água

Notas críticas sobre migração

Conversão de assíncrono para síncrono

Eliminação do ciclo de vida do processador

Alteração do padrão de configuração

Anotação em marcas d'água HTML

Tratamento de números de página

Solução de problemas

Problema 1: Processador de PDF não encontrado

Problema 2: GeneratePdfFromHtmlStringAsync não encontrado

Problema 3: Anotação de texto não encontrada

Problema 4: MergeAsync não encontrado

Lista de verificação para migração

Pré-migração

Alterações no pacote

Alterações no código

Pós-migração

Equipe de suporte de ferro

Experimente gratuitamente por 30 dias.

Como migrar do Nutrient.io para o IronPDF em C#

Por que migrar do Nutrient.io para o IronPDF?

O Problema da Complexidade da Plataforma

Comparação entre Nutrient.io e IronPDF

Antes de começar

Pré-requisitos

Alterações no pacote NuGet

Configuração de licença

Identificar o uso do Nutrient.io

Referência completa da API

Mapeamentos de inicialização

Mapeamentos de carregamento de documentos

Mapeamentos de geração de PDF

Mapeamentos de operações de documentos

Mapeamento de anotações e marcas d'água

Exemplos de migração de código

Exemplo 1: Conversão de HTML para PDF

Exemplo 2: Mesclar vários PDFs

Exemplo 3: Adicionando marcas d'água

Notas críticas sobre migração

Conversão de assíncrono para síncrono

Eliminação do ciclo de vida do processador

Alteração do padrão de configuração

Anotação em marcas d'água HTML

Tratamento de números de página

Solução de problemas

Problema 1: Processador de PDF não encontrado

Problema 2: GeneratePdfFromHtmlStringAsync não encontrado

Problema 3: Anotação de texto não encontrada

Problema 4: MergeAsync não encontrado

Lista de verificação para migração

Pré-migração

Alterações no pacote

Alterações no código

Pós-migração

Artigos relacionados

Como migrar do ZetPDF para o IronPDF em C#

Como migrar do Scryber.Core para o IronPDF em C#

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

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de suporte de ferro