GUIDES DE MIGRATION

Comment migrer de Nutrient.io à IronPDF en C#

Mis à jour:1 février 2026

La migration de Nutrient.io (anciennement PSPDFKit) versIronPDFsimplifie votre flux de travail PDF .NET en passant d'une plateforme d'intelligence documentaire complexe avec des modèles asynchrones d'abord à une bibliothèque PDF ciblée avec des API synchrones directes. Ce guide fournit un chemin de migration complet, étape par étape, qui élimine la surcharge de la plateforme tout en conservant toutes les fonctionnalités PDF essentielles.

Pourquoi migrer de Nutrient.io à IronPDF

Le problème de la complexité des plateformes

Nutrient.io (anciennement PSPDFKit) est passé d'un SDK PDF à une "plateforme d'intelligence documentaire" complète Bien que cette transformation élargisse les capacités, elle introduit des défis importants pour les équipes qui ont simplement besoin d'opérations PDF fiables :

Sur-ingénierie de la plateforme : ce qui était autrefois un SDK PDF est maintenant une plateforme complète d'intelligence documentaire avec des fonctionnalités d'IA et des capacités de flux de travail documentaire qui peuvent être inutiles pour les tâches PDF simples.
Tarification Enterprise : Nutrient.io est conçu pour les grandes organisations dont la tarification opaque nécessite de contacter le service commercial. Cela crée des obstacles pour les petites et moyennes équipes et rend la planification du budget difficile.
Confusion liée au changement de nom : La transition de PSPDFKit à Nutrient a engendré des problèmes de documentation, les deux noms étant toujours mentionnés. Les noms de paquets peuvent encore utiliser PSPDFKit, et les procédures de migration restent floues.
Complexité axée sur l'asynchrone : tout dans Nutrient.io nécessite des modèles async/await. Même les opérations simples nécessitent PdfProcessor.CreateAsync() pour l'initialisation et des méthodes asynchrones pour les tâches de base, ajoutant une surcharge pour les flux de travail synchrones.
Dépendances importantes : La plateforme complète nécessite plus de ressources, avec une empreinte mémoire plus importante, un temps d'initialisation plus long et une configuration supplémentaire.

Comparaison entreIronPDFet Nutrient.io

Aspect	Nutrient.io (PSPDFKit)	IronPDF
Objectif	Plate-forme d'intelligence documentaire	Bibliothèque PDF
Tarifs	Entreprise (contacter les ventes)	Transparent, publié
Architecture	Plateforme complexe	Bibliothèque simple
Style API	Async-first	Sync avec options asynchrones
Dépendances	Lourdeur	Léger
Configuration	Objets de configuration complexes	Propriétés simples
Courbe d'apprentissage	Steep (plateforme)	Gentle (bibliothèque)
Utilisateurs cibles	Entreprise	Toutes tailles d'équipe

Pour les équipes qui prévoient l'adoption de .NET 10 et C# 14 d'ici 2025 et 2026,IronPDFconstitue une base plus simple qui s'intègre proprement sans les frais généraux d'une plateforme complète d'intelligence documentaire.

Avant de commencer

Prérequis

Environnement .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
Accès à NuGet : possibilité d'installer des packages NuGet
Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet 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

Configurationde la licence

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

Identifier l'utilisation de 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

Référence API complète

Mappages d'initialisation

Nutrient.io (PSPDFKit)	IronPDF
`await PdfProcessor.CreateAsync()`	`new ChromePdfRenderer()`
`processor.Dispose()`	(automatique ou manuel)
`nouvelle configuration Pdf { ... }`	`renderer.RenderingOptions`

Mappages de chargement de documents

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

Mappages de génération 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)`

Mise en correspondance des opérations sur les documents

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`

Mappages d'annotations et de filigranes

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

Exemples de migration de code

Exemple 1 : Conversion HTML vers PDF

Avant (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

Aprè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

L'approche Nutrient.io nécessite plusieurs étapes asynchrones : la création d'un PdfProcessor avec await PdfProcessor.CreateAsync(), puis l'appel de await processor.GeneratePdfFromHtmlStringAsync(), et enfin de await document.SaveAsync(). La méthode entière doit être marquée async Task, et le processeur nécessite une instruction using pour une élimination correcte.

IronPDF simplifie considérablement cette tâche. Créez un ChromePdfRenderer, appelez RenderHtmlAsPdf() et enregistrez avec SaveAs(). Aucun async/await requis, aucun cycle de vie du processeur à gérer et aucun bloc using nécessaire pour les opérations simples. Ce modèle est plus intuitif pour les développeurs qui n'ont pas besoin de modèles asynchrones pour leur flux de travail PDF. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Fusionner plusieurs PDF

Avant (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

Aprè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

L'opération de fusion Nutrient.io nécessite la création d'un processeur avec await PdfProcessor.CreateAsync(), l'ouverture de chaque document avec des appels séparés await processor.OpenAsync(), la création d'un List<PdfDocument>, l'appel de await processor.MergeAsync() avec cette liste, et enfin await mergedDocument.SaveAsync(). Cela représente cinq opérations asynchrones pour une fusion de base.

IronPDF réduit cela à quatre lignes synchrones : charger chaque PDF avec PdfDocument.FromFile(), fusionner avec la méthode statique PdfDocument.Merge() et enregistrer. Pas de cycle de vie du processeur, pas de création de liste nécessaire (vous pouvez passer les documents directement), et pas de surcharge asynchrone. En savoir plus sur la fusion et la division de PDF.

Exemple 3 : Ajout de filigranes

Avant (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

Aprè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

Cet exemple met en évidence une différence architecturale fondamentale. Nutrient.io utilise une approche basée sur les annotations : vous créez un objet TextAnnotation avec des propriétés comme Opacity et FontSize, puis vous parcourez chaque page en appelant await document.AddAnnotationAsync(i, watermark) pour chacune d'elles. Cela implique de comprendre le système d'annotation et de gérer soi-même la boucle.

IronPDF utilise une approche basée sur HTML : la méthode ApplyWatermark() accepte une chaîne HTML avec un style CSS. Le filigrane est automatiquement appliqué à toutes les pages en un seul appel. Vous contrôlez l'apparence via des propriétés CSS familières (color, opacity, font-size) plutôt que des propriétés d'objet spécifiques à l'annotation. Cette approche offre une plus grande souplesse de style : vous pouvez utiliser n'importe quel code HTML/CSS, y compris des dégradés, des images et des mises en page complexes. Consultez la documentation sur les filigranes pour des exemples avancés.

Notes de migration essentielles

Conversion asynchrone vers synchrone

Le changement le plus important consiste à supprimer les modèles async/await inutiles :

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

Si vous avez besoin d'opérations asynchrones,IronPDFfournit des variantes asynchrones comme RenderHtmlAsPdfAsync().

Élimination du cycle de vie du processeur

Nutrient.io nécessite la création et l'élimination de processeurs :

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

Modification du modèle de configuration

Nutrient.io utilise des objets de configuration ;IronPDFutilise des propriétés :

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

Annotation en filigrane HTML

Remplacer les objets d'annotation par des chaînes 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

Gestion des numéros de page

Nutrient.io nécessite un comptage manuel des pages ;IronPDFdispose de caractères de remplacement intégrés :

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

Dépannage

Édition 1 : PdfProcessor introuvable

Problème : la classe PdfProcessor n'existe pas dans IronPDF.

Solution : Utilisez 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

Sujet 2 : GeneratePdfFromHtmlStringAsync introuvable

Problème : La méthode HTML asynchrone n'existe pas.

Solution : Utilisez 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

Sujet 3 : TextAnnotation Not Found

Problème : les classes d'annotations n'existent pas dans IronPDF.

Solution : Utiliser des filigranes 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

Edition 4 : MergeAsync introuvable

Problème : La méthode de fusion asynchrone n'existe pas.

Solution : Utiliser statique 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

Liste de contrôle de la migration

Pré-migration

Inventorier toutes les utilisations de PSPDFKit/Nutrient dans le code source
Documenter les modèles asynchrones qui pourraient nécessiter des ajustements
Lister tous les objets de configuration et leurs propriétés
Identifier les caractéristiques basées sur les annotations (filigranes, en-têtes)
Examiner les exigences de traitement des formulaires
Obtenir une clé de licence IronPDF

Modifications du paquet

Supprimer le package NuGet PSPDFKit.NET
Supprimer le package NuGet Nutrient
Installez le package NuGet IronPdf : dotnet add package IronPdf
Mettre à jour les importations d'espace de noms

Modifications du code

Ajouter la configuration de la clé de licence au démarrage
Remplacez PdfProcessor.CreateAsync() par new ChromePdfRenderer()
Remplacez processor.GeneratePdfFromHtmlStringAsync() par renderer.RenderHtmlAsPdf()
Remplacez processor.MergeAsync() par PdfDocument.Merge()
Convertir les filigranes TextAnnotation en filigranes HTML
Remplacez les objets de configuration par les propriétés RenderingOptions
Mettre à jour l'en-tête/le pied de page pour utiliser HtmlHeaderFooter avec des espaces réservés
Supprimer les modèles async/await inutiles

Après la migration

Supprimez les blocs async/await lorsqu'ils ne sont plus nécessaires.
Effectuer des tests de régression comparant les résultats PDF
Vérifier que les en-têtes et pieds de page correspondent aux numéros de page
Test du rendu du filigrane
Mise à jour du pipeline CI/CD

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Articles connexes

Mis à jour1 février 2026

Comment migrer de ZetPDF à IronPDF en C#

Maîtrisez la migration de ZetPDF vers IronPDF grâce à ce guide C# complet. Passez d'une bibliothèque basée sur les coordonnées à une solution HTML-PDF moderne. Inclut des exemples de code pour la conversion HTML, la fusion de PDF et la suppression des dépendances PDFSharp.

Mis à jour1 février 2026

Comment migrer de Scryber.Core vers IronPDF en C#

Maîtrisez la migration de Scryber.Core vers IronPDF grâce à ce guide complet en C#. Passez d'une analyse XML/HTML personnalisée à un moteur de rendu moderne Chromium. Inclut des exemples de code pour la conversion HTML, le rendu d'URL et le remplacement des liaisons propriétaires.

Mis à jour1 février 2026

Comment migrer de XFINIUM.PDF vers IronPDF en C#

Maîtrisez la migration de XFINIUM.PDF vers IronPDF grâce à ce guide C# complet. Passez d'un positionnement manuel basé sur les coordonnées à un rendu HTML/CSS déclaratif. Inclut des exemples de code pour le remplacement des primitives graphiques et la mise en page automatique.

Comment migrer de PDFBolt vers IronPDF en C#

Comment migrer d'un générateur de...

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

Comment migrer de Nutrient.io à IronPDF en C#

Pourquoi migrer de Nutrient.io à IronPDF

Le problème de la complexité des plateformes

Comparaison entreIronPDFet Nutrient.io

Avant de commencer

Prérequis

Modifications du paquet NuGet

Configurationde la licence

Identifier l'utilisation de Nutrient.io

Référence API complète

Mappages d'initialisation

Mappages de chargement de documents

Mappages de génération de PDF

Mise en correspondance des opérations sur les documents

Mappages d'annotations et de filigranes

Exemples de migration de code

Exemple 1 : Conversion HTML vers PDF

Exemple 2 : Fusionner plusieurs PDF

Exemple 3 : Ajout de filigranes

Notes de migration essentielles

Conversion asynchrone vers synchrone

Élimination du cycle de vie du processeur

Modification du modèle de configuration

Annotation en filigrane HTML

Gestion des numéros de page

Dépannage

Édition 1 : PdfProcessor introuvable

Sujet 2 : GeneratePdfFromHtmlStringAsync introuvable

Sujet 3 : TextAnnotation Not Found

Edition 4 : MergeAsync introuvable

Liste de contrôle de la migration

Pré-migration

Modifications du paquet

Modifications du code

Après la migration

Équipe de soutien Iron

Essai gratuit de 30 jours

Comment migrer de Nutrient.io à IronPDF en C#

Pourquoi migrer de Nutrient.io à IronPDF

Le problème de la complexité des plateformes

Comparaison entreIronPDFet Nutrient.io

Avant de commencer

Prérequis

Modifications du paquet NuGet

Configurationde la licence

Identifier l'utilisation de Nutrient.io

Référence API complète

Mappages d'initialisation

Mappages de chargement de documents

Mappages de génération de PDF

Mise en correspondance des opérations sur les documents

Mappages d'annotations et de filigranes

Exemples de migration de code

Exemple 1 : Conversion HTML vers PDF

Exemple 2 : Fusionner plusieurs PDF

Exemple 3 : Ajout de filigranes

Notes de migration essentielles

Conversion asynchrone vers synchrone

Élimination du cycle de vie du processeur

Modification du modèle de configuration

Annotation en filigrane HTML

Gestion des numéros de page

Dépannage

Édition 1 : PdfProcessor introuvable

Sujet 2 : GeneratePdfFromHtmlStringAsync introuvable

Sujet 3 : TextAnnotation Not Found

Edition 4 : MergeAsync introuvable

Liste de contrôle de la migration

Pré-migration

Modifications du paquet

Modifications du code

Après la migration

Articles connexes

Comment migrer de ZetPDF à IronPDF en C#

Comment migrer de Scryber.Core vers IronPDF en C#

Comment migrer de XFINIUM.PDF vers IronPDF en 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?

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron