MIGRATIONSLEITFäDEN

Wie man von Nutrient.io zu IronPDF in C# migriert

Aktualisiert:1. Februar 2026

Die Migration von Nutrient.io (ehemals PSPDFKit) zu IronPDF vereinfacht Ihren .NET-PDF-Workflow durch den Wechsel von einer komplexen Document-Intelligence-Plattform mit Async-First-Patterns zu einer fokussierten PDF-Bibliothek mit einfachen synchronen APIs. Dieser Leitfaden bietet einen umfassenden, schrittweisen Migrationspfad, der den Plattform-Overhead eliminiert und gleichzeitig alle wesentlichen PDF-Funktionen beibehält.

Warum von Nutrient.io zu IronPDF migrieren

Das Problem der Plattformkomplexität

Nutrient.io (ehemals PSPDFKit) hat sich von einem PDF-SDK zu einer umfassenden "Document Intelligence Platform" entwickelt Dieser Wandel erweitert zwar die Möglichkeiten, stellt aber Teams, die einfach nur zuverlässige PDF-Vorgänge benötigen, vor große Herausforderungen:

Überentwicklung der Plattform: Was einst ein PDF SDK war, ist heute eine vollständige Dokumentenintelligenzplattform mit KI-Funktionen und Dokumenten-Workflow-Funktionen, die für einfache PDF-Aufgaben möglicherweise unnötig sind.
Enterprise Preisgestaltung: Nutrient.io richtet sich an große Organisationen mit intransparenter Preisgestaltung, die den Kontakt zum Vertrieb erfordert. Dies stellt eine Hürde für kleine bis mittelgroße Teams dar und erschwert die Budgetplanung.
Verwirrung durch die Umbenennung: Der Übergang von PSPDFKit zu Nutrient hat zu Dokumentationsproblemen geführt, da beide Namen verwendet werden. Paketnamen verwenden möglicherweise noch PSPDFKit, und die Migrationspfade während des Übergangs sind weiterhin unklar.
Komplexität durch Async-First: Alles in Nutrient.io erfordert async/await-Muster. Selbst einfache Operationen benötigen PdfProcessor.CreateAsync() zur Initialisierung und asynchrone Methoden für grundlegende Aufgaben, was zusätzlichen Aufwand für synchrone Arbeitsabläufe bedeutet.
Hohe Abhängigkeiten: Die vollständige Plattform benötigt mehr Ressourcen, was sich in einem größeren Paketumfang, längeren Initialisierungszeiten und zusätzlichem Konfigurationsaufwand äußert.

Nutrient.io vs IronPDFVergleich

Aspekt	Nutrient.io (PSPDFKit)	IronPDF
Schwerpunkt	Document Intelligence-Plattform	PDF-Bibliothek
Preisgestaltung	Unternehmen (Kontakt zum Vertrieb)	Transparent, veröffentlicht
Architektur	Komplexe Plattform	Einfache Bibliothek
API-Stil	Async-first	Sync mit asynchronen Optionen
Abhängigkeiten	Schwer	Leichtgewichtig
Konfiguration	Komplexe Konfigurationsobjekte	Unkomplizierte Eigenschaften
Lernkurve	Steep (Plattform)	Gentle (Bibliothek)
Zielbenutzer	Unternehmen	Alle Teamgrößen

Für Teams, die die Einführung von .NET 10 und C# 14 bis zum Jahr 2025 bzw. 2026 planen, bietet IronPDF eine einfachere Grundlage, die sich ohne den Overhead einer vollständigen Document Intelligence-Plattform sauber integrieren lässt.

Bevor Sie beginnen

Voraussetzungen

.NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# 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

Lizenz-Konfiguration

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

Nutrient.io-Verwendung identifizieren

# 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

Komplette API-Referenz

Initialisierungs-Zuordnungen

Nutrient.io (PSPDFKit)	IronPDF
`await PdfProcessor.CreateAsync()`	`new ChromePdfRenderer()`
`processor.Dispose()`	(automatisch oder manuell)_
`new PdfConfiguration { ... }`	`renderer.RenderingOptions`

Zuordnungen beim Laden von Dokumenten

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

Zuordnungen für die PDF-Erzeugung

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)`

Zuordnungen von Dokumentenoperationen

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`

Anmerkungen und Wasserzeichen-Zuordnungen

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

Beispiele für die Code-Migration

Beispiel 1: Konvertierung von HTML in PDF

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

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

Der Ansatz von Nutrient.io erfordert mehrere asynchrone Schritte: Erstellen eines PdfProcessor mit await PdfProcessor.CreateAsync(), dann Aufruf von await processor.GeneratePdfFromHtmlStringAsync() und schließlich await document.SaveAsync(). Die gesamte Methode muss mit async Task gekennzeichnet werden, und der Prozessor benötigt eine using Anweisung zur ordnungsgemäßen Entsorgung.

IronPDF vereinfacht dies dramatisch. Erstelle ein ChromePdfRenderer, rufe RenderHtmlAsPdf() auf und speichere mit SaveAs(). Kein async/await erforderlich, kein Prozessorlebenszyklus muss verwaltet werden und für einfache Operationen werden keine using Blöcke benötigt. Dieses Muster ist für Entwickler, die keine asynchronen Muster für ihren PDF-Workflow benötigen, intuitiver. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Zusammenführen mehrerer PDFs

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

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

Für den Merge-Vorgang von Nutrient.io ist es erforderlich, einen Prozessor mit await PdfProcessor.CreateAsync() zu erstellen, jedes Dokument mit separaten await processor.OpenAsync()-Aufrufen zu öffnen, einen List<PdfDocument> zu erstellen, await processor.MergeAsync() mit dieser Liste aufzurufen und schließlich await mergedDocument.SaveAsync(). Das sind fünf asynchrone Operationen für eine einfache Zusammenführung.

IronPDF reduziert dies auf vier synchrone Zeilen: Laden Sie jedes PDF mit PdfDocument.FromFile(), führen Sie es mit der statischen Methode PdfDocument.Merge() zusammen und speichern Sie es. Kein Prozessor-Lebenszyklus, keine Listenerstellung erforderlich (Sie können Dokumente direkt übergeben) und kein asynchroner Overhead. Erfahren Sie mehr über das Zusammenführen und Aufteilen von PDFs.

Beispiel 3: Hinzufügen von Wasserzeichen

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

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

Dieses Beispiel verdeutlicht einen grundlegenden architektonischen Unterschied. Nutrient.io verwendet einen annotationsbasierten Ansatz: Sie erstellen ein TextAnnotation Objekt mit Eigenschaften wie Opacity und FontSize, und durchlaufen dann jede Seite, indem Sie für jede await document.AddAnnotationAsync(i, watermark) aufrufen. Dazu ist es erforderlich, das Anmerkungssystem zu verstehen und die Schleife selbst zu verwalten.

IronPDF verwendet einen HTML-basierten Ansatz: Die Methode ApplyWatermark() akzeptiert eine HTML-Zeichenkette mit CSS-Styling. Das Wasserzeichen wird automatisch auf alle Seiten in einem einzigen Aufruf angewendet. Sie steuern das Erscheinungsbild über vertraute CSS-Eigenschaften (color, opacity, font-size) anstatt über annotationsspezifische Objekteigenschaften. Dieser Ansatz bietet mehr Flexibilität bei der Gestaltung - Sie können beliebiges HTML/CSS verwenden, einschließlich Farbverläufen, Bildern und komplexen Layouts. Weitere Beispiele finden Sie in der Dokumentation zum Wasserzeichen .

Kritische Hinweise zur Migration

Async zu Sync Konvertierung

Die wichtigste Änderung ist das Entfernen unnötiger async/await-Muster:

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

Falls Sie asynchrone Operationen benötigen, bietet IronPDF asynchrone Varianten wie RenderHtmlAsPdfAsync() an.

Prozessor-Lebenszyklus-Eliminierung

Nutrient.io erfordert die Erstellung und Entsorgung von Prozessoren:

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

Änderung von Konfigurationsmustern

Nutrient.io verwendet Konfigurationsobjekte;IronPDF verwendet Eigenschaften:

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

Anmerkungen zu HTML-Wasserzeichen

Ersetzen Sie Anmerkungsobjekte durch HTML-Strings:

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

Behandlung von Seitenzahlen

Nutrient.io erfordert eine manuelle Seitenzählung;IronPDF verfügt über integrierte Platzhalter:

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

Fehlerbehebung

Ausgabe 1: PdfProcessor nicht gefunden

Problem: Die Klasse PdfProcessor existiert nicht in IronPDF.

Lösung: Verwenden Sie 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

Ausgabe 2: GeneratePdfFromHtmlStringAsync nicht gefunden

Problem: Die Methode Async HTML existiert nicht.

Lösung: Verwenden Sie 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

Ausgabe 3: TextAnnotation nicht gefunden

Problem: Annotationsklassen existieren in IronPDF nicht.

Lösung: HTML-basierte Wasserzeichen verwenden:

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

Ausgabe 4: MergeAsync nicht gefunden

Problem: Die Methode "Async merge" existiert nicht.

Lösung: Verwenden Sie statische 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

Migrations-Checkliste

Vor der Migration

Erfassung aller PSPDFKit/Nährstoffverwendungen im Quellcode
Dokumentieren Sie asynchrone Muster, die möglicherweise angepasst werden müssen.
Listet alle Konfigurationsobjekte und ihre Eigenschaften auf
Identifizierung von annotationsbasierten Merkmalen (Wasserzeichen, Header)
Überprüfung der Anforderungen an die Formularbearbeitung -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

Entfernen Sie das NuGet Paket PSPDFKit.NET
Entfernen Sie das NuGet Paket Nutrient
Installieren Sie das NuGet Paket IronPdf: dotnet add package IronPdf
Namespace-Importe aktualisieren

Code-Änderungen

Lizenzschlüsselkonfiguration beim Start hinzufügen
Ersetzen Sie PdfProcessor.CreateAsync() durch new ChromePdfRenderer()
Ersetzen Sie processor.GeneratePdfFromHtmlStringAsync() durch renderer.RenderHtmlAsPdf()
Ersetzen Sie processor.MergeAsync() durch PdfDocument.Merge()
Konvertiere TextAnnotation Wasserzeichen in HTML-Wasserzeichen
Ersetzen Sie Konfigurationsobjekte durch RenderingOptions Eigenschaften
Aktualisieren Sie Kopf- und Fußzeile, um HtmlHeaderFooter mit Platzhaltern zu verwenden
Unnötige async/await-Muster entfernen

Nach der Migration

Entfernen Sie async/await, wo es nicht mehr benötigt wird.
Führen Sie Regressionstests durch, um die PDF-Ausgabe zu vergleichen.
Überprüfen Sie die Kopf- und Fußzeilen mit den Seitenzahlen.
Test der Wasserzeichenwiedergabe
CI/CD-Pipeline aktualisieren

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man von Nutrient.io zu IronPDF in C# migriert

Warum von Nutrient.io zu IronPDF migrieren

Das Problem der Plattformkomplexität

Nutrient.io vs IronPDFVergleich

Bevor Sie beginnen

Voraussetzungen

NuGet-Paketänderungen

Lizenz-Konfiguration

Nutrient.io-Verwendung identifizieren

Komplette API-Referenz

Initialisierungs-Zuordnungen

Zuordnungen beim Laden von Dokumenten

Zuordnungen für die PDF-Erzeugung

Zuordnungen von Dokumentenoperationen

Anmerkungen und Wasserzeichen-Zuordnungen

Beispiele für die Code-Migration

Beispiel 1: Konvertierung von HTML in PDF

Beispiel 2: Zusammenführen mehrerer PDFs

Beispiel 3: Hinzufügen von Wasserzeichen

Kritische Hinweise zur Migration

Async zu Sync Konvertierung

Prozessor-Lebenszyklus-Eliminierung

Änderung von Konfigurationsmustern

Anmerkungen zu HTML-Wasserzeichen

Behandlung von Seitenzahlen

Fehlerbehebung

Ausgabe 1: PdfProcessor nicht gefunden

Ausgabe 2: GeneratePdfFromHtmlStringAsync nicht gefunden

Ausgabe 3: TextAnnotation nicht gefunden

Ausgabe 4: MergeAsync nicht gefunden

Migrations-Checkliste

Vor der Migration

Paketänderungen

Code-Änderungen

Nach der Migration

Iron Support Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man von Nutrient.io zu IronPDF in C# migriert

Warum von Nutrient.io zu IronPDF migrieren

Das Problem der Plattformkomplexität

Nutrient.io vs IronPDFVergleich

Bevor Sie beginnen

Voraussetzungen

NuGet-Paketänderungen

Lizenz-Konfiguration

Nutrient.io-Verwendung identifizieren

Komplette API-Referenz

Initialisierungs-Zuordnungen

Zuordnungen beim Laden von Dokumenten

Zuordnungen für die PDF-Erzeugung

Zuordnungen von Dokumentenoperationen

Anmerkungen und Wasserzeichen-Zuordnungen

Beispiele für die Code-Migration

Beispiel 1: Konvertierung von HTML in PDF

Beispiel 2: Zusammenführen mehrerer PDFs

Beispiel 3: Hinzufügen von Wasserzeichen

Kritische Hinweise zur Migration

Async zu Sync Konvertierung

Prozessor-Lebenszyklus-Eliminierung

Änderung von Konfigurationsmustern

Anmerkungen zu HTML-Wasserzeichen

Behandlung von Seitenzahlen

Fehlerbehebung

Ausgabe 1: PdfProcessor nicht gefunden

Ausgabe 2: GeneratePdfFromHtmlStringAsync nicht gefunden

Ausgabe 3: TextAnnotation nicht gefunden

Ausgabe 4: MergeAsync nicht gefunden

Migrations-Checkliste

Vor der Migration

Paketänderungen

Code-Änderungen

Nach der Migration

Verwandte Artikel

Wie man von ZetPDF zu IronPDF in C# migriert

Wie man von Scryber.Core zu IronPDF in C# migriert

Migrieren von XFINIUM.PDF zu IronPDF in 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?

Von Millionen von Ingenieur*innen weltweit vertraut

Iron Support Team