MIGRATIONSLEITFäDEN

Migrieren von ActivePDF zu IronPDF: (.NET-Leitfaden)

Veröffentlicht:11. Januar 2026

ActivePDF ist seit langem ein zuverlässiges PDF-Toolkit für .NET-Entwickler. Seit der Übernahme durch Foxit herrscht jedoch bei vielen Entwicklerteams Unsicherheit über die Zukunft der Plattform, die Lizenzbedingungen und die weitere Entwicklung. Dieser Leitfaden bietet eine umfassende, schrittweise Anleitung zur Migration von ActivePDFzuIronPDF– einer modernen, aktiv gepflegten .NET PDF-Bibliothek, die .NET Framework 4.6.2 bis .NET 9 und darüber hinaus unterstützt.

Warum sollten Sie einen Wechsel von ActivePDFin Betracht ziehen?

Die Übernahme von ActivePDFdurch Foxit hat für Entwickler, die an Lösungen zur PDF-Generierung und -Manipulation in .NET-Anwendungen arbeiten, mehrere Herausforderungen mit sich gebracht.

Ungewisse Produktzukunft

Der Übergang von ActivePDFunter die Eigentümerschaft von Foxit wirft Fragen hinsichtlich der langfristigen Entwicklung des Toolkits auf. Entwickler, die auf ActivePDFangewiesen sind, laufen Gefahr, dass die Bibliothek durch reduzierten Support und stagnierende Weiterentwicklung veraltet. Für Teams, die Projekte planen, die sich bis ins Jahr 2025 und 2026 erstrecken, stellt diese Unsicherheit ein erhebliches technisches Risiko dar.

Komplikationen bei der Lizenzierung

Die Übernahme hat zu Unsicherheiten bei der Lizenzierung geführt, die den Einsatz erschweren können. Das traditionelle maschinengebundene Lizenzierungsmodell von ActivePDFführt zu Reibungsverlusten in modernen Cloud- und Container-Umgebungen, in denen Anwendungen dynamisch über die Infrastruktur skaliert werden.

Legacy-Architektur-Muster

Die Architektur von ActivePDFspiegelt eine ältere Design-Philosophie wider, die sich auf zustandsbehaftete Toolkit-Muster konzentriert. Der OpenOutputFile/CloseOutputFile-Workflow erfordert eine explizite Dateihandle-Verwaltung, die nicht mit modernen C#-Konventionen übereinstimmt und bei unvorsichtiger Handhabung zu Problemen bei der Ressourcenverwaltung führen kann.

Installations- und Konfigurationsaufwand

Im Gegensatz zur heutigen NuGet-basierten Paketverwaltung erfordert ActivePDFhäufig manuelle DLL-Referenzen und eine explizite Pfadkonfiguration bei der Instanziierung des Toolkits - ein Muster, das die Reibungsverluste beim Onboarding erhöht und CI/CD-Pipelines verkompliziert.

ActivePDFvs. IronPDF: Hauptunterschiede

Bevor man mit dem Migrationsprozess beginnt, hilft das Verständnis der grundlegenden Unterschiede zwischen ActivePDFundIronPDFdabei, realistische Erwartungen hinsichtlich der erforderlichen Codeänderungen zu formulieren.

Aspekt	ActivePDF	IronPDF
Firmenstatus	Erworben von Foxit (ungewisse Zukunft)	Unabhängiger, klarer Entwicklungsfahrplan
Installation	Handbuch DLL-Referenzen	Einfaches NuGet-Paket
API-Muster	Stateful (`OpenOutputFile`/`CloseOutputFile`)	Fließende, funktionale API
Lizenzmodell	Maschinengekoppelt	Code-basierter Schlüssel
.NET-Unterstützung	Schwerpunkt Legacy .NET Framework	Framework 4.6.2 zu .NET 9+
Fehlerbehandlung	Integer-Rückgabecodes	Moderne ausnahmebasierte
Async-Unterstützung	Nicht verfügbar	Vollständige Unterstützung von async/await

Vorbereitung auf die Migration

Überprüfen Sie Ihre Codebase

Bevor Sie mit der Migration beginnen, sollten Sie die gesamte ActivePDF-Nutzung in Ihrer Lösung identifizieren. Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus:

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

SHELL

Änderungen an den Dokumenten

Das Verständnis der grundlegenden API-Unterschiede hilft bei der Planung Ihrer Migrationsstrategie:

Kategorie	ActivePDF-Verhalten	IronPDF-Verhalten	Migration Aktion
Objektmodell	Einzelnes `Toolkit`-Objekt	`ChromePdfRenderer` + `PdfDocument`	Getrennte Anliegen
Dateioperationen	`OpenOutputFile()`/`CloseOutputFile()`	Direkt `SaveAs()`	Öffnen/Schließen-Aufrufe entfernen
Erstellung der Seite	`NeueSeite()` Methode	Automatisch aus HTML	Aufrufe zur Seitenerstellung entfernen
Rückgabewerte	Integer-Fehlercodes	Ausnahmen	Try/Catch implementieren
Seitengröße Einheiten	Punkte (612x792 = Buchstabe)	Enums oder Millimeter	Messungen aktualisieren

Voraussetzungen

Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:

.NET Framework 4.6.2+ oder .NET Core 3.1 / .NET 5-9
Visual Studio 2019+ oder JetBrains Rider
NuGet Package Manager Zugang
IronPDF-Lizenzschlüssel (kostenlose Testversion erhältlich unter ironpdf.com)

Schritt-für-Schritt-Migrationsprozess

Schritt 1: NuGet-Pakete aktualisieren

Entfernen Sie das ActivePDF-Paket und installieren Sie IronPDF:

# Remove ActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

# Remove ActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

SHELL

Alternativ kann die Übersetzung auch über die Visual Studio Package Manager Console erfolgen:

Uninstall-Package APToolkitNET
Install-Package IronPdf

Bei Projekten mit manuellen DLL-Referenzen entfernen Sie die Referenz aus Ihrer .csproj-Datei:


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>

XML

Schritt 2: Konfigurieren des Lizenzschlüssels

Fügen Sie den IronPDF-Lizenzschlüssel beim Starten der Anwendung vor allen PDF-Vorgängen hinzu:

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

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

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

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

$vbLabelText $csharpLabel

Schritt 3: Aktualisieren der Namensraum-Referenzen

Führen Sie ein globales Suchen und Ersetzen in Ihrer Lösung durch:

Finden Sie	Ersetzen durch
`Verwendung von ActivePDF.Toolkit;`	`IronPdf verwenden;`
`Verwendung von APToolkitNET;`	`IronPdf verwenden;`
`Verwendung von APToolkitNET.PDFObjects;`	`IronPdf verwenden;`
`Verwendung von APToolkitNET.Common;`	`IronPdf verwenden;`

Komplette API-Migrationsreferenz

Methoden der Dokumentenerstellung

ActivePDF-Methode	IronPDF-Äquivalent	Notizen
`new Toolkit()`	`new ChromePdfRenderer()`	Renderer erstellt PDFs
`toolkit.OpenOutputFile(path)`	Kein Äquivalent erforderlich	Einfach `SaveAs()` am Ende aufrufen
`toolkit.CloseOutputFile()`	Kein Äquivalent erforderlich	Automatische Bereinigung
`toolkit.AddHTML(html)`	`renderer.RenderHtmlAsPdf(html)`	Rückgabe `PdfDocument`
`toolkit.AddURL(url)`	`renderer.RenderUrlAsPdf(url)`	URL zu PDF Konvertierung
`toolkit.SaveAs(Pfad)`	`pdf.SaveAs(Pfad)`	In Datei speichern

Dateioperationen

ActivePDF-Methode	IronPDF-Äquivalent	Notizen
`toolkit.OpenInputFile(Pfad)`	`PdfDocument.FromFile(path)`	Vorhandenes PDF laden
`toolkit.AddPDF(Pfad)`	`PdfDocument.Merge()`	Für die Zusammenführung von Operationen
`toolkit.GetPageCount()`	`pdf.PageCount`	Zugang zu den Eigenschaften
`toolkit.GetText()`	`pdf.ExtractAllText()`	Textextraktion

Seitenkonfiguration

ActivePDF-Methode	IronPDF-Äquivalent
`toolkit.SetPageSize(612, 792)`	`RenderingOptions.PaperSize = PdfPaperSize.Letter`
`toolkit.SetOrientation("Querformat")`	`RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape`
`toolkit.SetMargins(t, b, l, r)`	`RenderingOptions.MarginTop/Bottom/Left/Right`

Sicherheitsmethoden

ActivePDF-Methode	IronPDF-Äquivalent
`toolkit.Encrypt(Passwort)`	`pdf.SecuritySettings.OwnerPassword`
`toolkit.SetUserPassword(pwd)`	`pdf.SecuritySettings.UserPassword`
`toolkit.SetPermissions(flags)`	`pdf.SecuritySettings.AllowUserXxx`
`toolkit.AddWatermark(text)`	`pdf.ApplyWatermark(html)`

Beispiele für die Code-Migration

HTML-zu-PDF-Konvertierung

Die Konvertierung von HTML-Strings in PDF-Dokumente ist eines der häufigsten Szenarien für die PDF-Erstellung. Hier sehen Sie, wie sich der Code während der Migration verändert.

ActivePDF-Einführung:

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

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

        Console.WriteLine("PDF created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

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

        Console.WriteLine("PDF created successfully");
    }
}

$vbLabelText $csharpLabel

Mit dem IronPDF-Ansatz entfällt die explizite Verwaltung von Dateihandles, während der Code sauberer und besser lesbar wird. Für fortgeschrittene HTML-zu-PDF-Szenarien verwendet der ChromePdfRenderer vonIronPDFeine Chromium-basierte Rendering-Engine für pixelgenaue CSS- und JavaScript-Unterstützung.

URL zu PDF-Konvertierung

Die Erfassung von Webseiten als PDF-Dokumente folgt einem ähnlichen Modernisierungsmuster.

ActivePDF-Einführung:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

$vbLabelText $csharpLabel

Mehrere PDFs zusammenführen

Die Kombination mehrerer PDF-Dokumente zu einer einzigen Datei demonstriert den funktionalen Ansatz vonIronPDFbei der Dokumentenmanipulation.

ActivePDF-Einführung:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;
using System;
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");

        Console.WriteLine("PDFs merged successfully");
    }
}

using IronPdf;
using System;
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");

        Console.WriteLine("PDFs merged successfully");
    }
}

$vbLabelText $csharpLabel

Weitere fortgeschrittene Zusammenführungsszenarien, einschließlich der selektiven Seitenextraktion, finden Sie in der PDF-Zusammenführungsdokumentation.

Kopf- und Fußzeilen einfügen

ActivePDF-Einführung:

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Arial"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}

using IronPdf;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Arial"
    };

    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(outputPath);
}

$vbLabelText $csharpLabel

IronPDF unterstützt sowohl textbasierte als auch HTML-Kopf- und -Fußzeilen und bietet somit vollständige Flexibilität bei der Gestaltung.

Passwortschutz und Sicherheit

ActivePDF-Einführung:

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}

using IronPdf;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.SecuritySettings.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = password;
    pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
    pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

    pdf.SaveAs(outputPath);
}

$vbLabelText $csharpLabel

IronPDFs Sicherheitseinstellungen-API bietet eine granulare Kontrolle über Dokumentberechtigungen mit stark typisierten Enums anstelle von Integer-Flags.

Textextraktion

ActivePDF-Einführung:

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}

$vbLabelText $csharpLabel

Die IronPDF-Implementierung reduziert die Textextraktion aus mehreren Zeilen auf einen einzigen Methodenaufruf.

Wasserzeichen hinzufügen

ActivePDF-Einführung:

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

$vbLabelText $csharpLabel

IronPDF-Implementierung:

using IronPdf;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

using IronPdf;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

$vbLabelText $csharpLabel

Das HTML-basierte Wasserzeichen vonIronPDFermöglicht CSS-Styling für eine vollständige Designkontrolle ohne seitenweise Iteration.

ASP.NET Core-Integration

Moderne Webanwendungen profitieren erheblich von den sauberen Integrationsmustern von IronPDF.

ActivePDF-Muster:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

$vbLabelText $csharpLabel

IronPDF-Muster:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

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

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

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

$vbLabelText $csharpLabel

IronPDF macht temporäre Dateien überflüssig und gibt die PDF-Binärdaten direkt aus dem Speicher zurück.

Async-Unterstützung für Webanwendungen

ActivePDF verfügt nicht über native async-Unterstützung.IronPDFbietet vollständige async/await-Funktionen, die für skalierbare Webanwendungen unerlässlich sind:

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

$vbLabelText $csharpLabel

Dependency Injection Konfiguration

Für Anwendungen mit .NET 6+ müssen Sie die IronPDF-Dienste in Ihrem DI-Container registrieren:

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

$vbLabelText $csharpLabel

Migration der Fehlerbehandlung

ActivePDF verwendet ganzzahlige Rückgabecodes, die Nachschlagetabellen erfordern.IronPDFverwendet eine moderne Ausnahmebehandlung:

ActivePDF-Fehlerbehandlung:

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

$vbLabelText $csharpLabel

IronPDF-Fehlerbehandlung:

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

$vbLabelText $csharpLabel

Tipps zur Leistungsoptimierung

Wiederverwendung der Renderer-Instanz

Das Erstellen eines neuen ChromePdfRenderer hat einen Initialisierungs-Overhead. Für Batch-Operationen eine einzelne Instanz wiederverwenden:

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

$vbLabelText $csharpLabel

Verwendung von Async in Webanwendungen

Bei ASP.NET Core-Anwendungen verbessert die asynchrone PDF-Generierung den Durchsatz:

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

public async Task<IActionResult> GenerateReport()
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

$vbLabelText $csharpLabel

Ressourcen richtig entsorgen

Verwenden Sie immer using-Anweisungen, um eine korrekte Bereinigung zu gewährleisten:

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

$vbLabelText $csharpLabel

Bildkomprimierung

Reduzieren Sie die Größe der Ausgabedatei mit Bildkomprimierung:

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

$vbLabelText $csharpLabel

Fehlerbehebung bei allgemeinen Migrationsproblemen

Problem: Unterschiede in der Seitengröße

ActivePDF verwendet Punkte (612x792 = Letter), währendIronPDFEnums oder Millimeter verwendet:

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

$vbLabelText $csharpLabel

Problem: Fehlendes CloseOutputFile-Äquivalent

IronPDF verwendet ein modernes Paradigma ohne explizites Dateihandle-Management:

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

//IronPDF- no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

//IronPDF- no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

$vbLabelText $csharpLabel

Ausgabe: PDF wird leer wiedergegeben

Wenn JavaScript-abhängiger Inhalt leer gerendert wird, konfigurieren Sie Rendering-Verzögerungen:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

$vbLabelText $csharpLabel

Problem: CSS/Bilder werden nicht geladen

Konfigurieren Sie die Basis-URL für die relative Pfadauflösung:

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

$vbLabelText $csharpLabel

Post-Migrations-Checkliste

Überprüfen Sie nach Abschluss der Codemigration Folgendes:

Alle vorhandenen Unit- und Integrationstests ausführen
Vergleichen Sie die PDF-Ausgaben visuell mit früheren Versionen
Testen Sie alle PDF-Workflows in einer Testumgebung
Überprüfen Sie, ob die Lizenzierung korrekt funktioniert ( IronPdf.License.IsLicensed )
Leistungsvergleich mit der vorherigen Implementierung
Entfernen Sie alte ActivePDF-Installationsdateien und DLL-Verweise.
CI/CD-Pipeline-Abhängigkeiten aktualisieren
Dokumentieren Sie IronPDF-Muster für Ihr Entwicklungsteam

Zukunftssicherheit für Ihre PDF-Lösung

Mit .NET 10 am Horizont und C# 14, das neue Sprachfunktionen einführt, stellt die Wahl einer .NET PDF-Bibliothek mit aktiver Entwicklung sicher, dass Ihre Anwendungen mit den sich entwickelnden Laufzeitfunktionen kompatibel bleiben. IronPDFs Engagement für die Unterstützung der neuesten .NET-Versionen bedeutet, dass sich Ihre Migrationsinvestition auszahlt, wenn Ihre Projekte bis ins Jahr 2025 und 2026 reichen.

Zusätzliche Ressourcen

Die Migration von ActivePDFzuIronPDFmodernisiert Ihre PDF-Erzeugungsinfrastruktur mit saubereren APIs, besserer .NET-Integration und aktivem Langzeit-Support. Die Investition in die Migration zahlt sich durch eine bessere Wartbarkeit des Codes, asynchrone Funktionen und das Vertrauen in die weitere Entwicklung Ihrer PDF-Bibliothek aus.

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

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Migrieren von ActivePDF zu IronPDF: (.NET-Leitfaden)

Warum sollten Sie einen Wechsel von ActivePDFin Betracht ziehen?

Ungewisse Produktzukunft

Komplikationen bei der Lizenzierung

Legacy-Architektur-Muster

Installations- und Konfigurationsaufwand

ActivePDFvs. IronPDF: Hauptunterschiede

Vorbereitung auf die Migration

Überprüfen Sie Ihre Codebase

Änderungen an den Dokumenten

Voraussetzungen

Schritt-für-Schritt-Migrationsprozess

Schritt 1: NuGet-Pakete aktualisieren

Schritt 2: Konfigurieren des Lizenzschlüssels

Schritt 3: Aktualisieren der Namensraum-Referenzen

Komplette API-Migrationsreferenz

Methoden der Dokumentenerstellung

Dateioperationen

Seitenkonfiguration

Sicherheitsmethoden

Beispiele für die Code-Migration

HTML-zu-PDF-Konvertierung

URL zu PDF-Konvertierung

Mehrere PDFs zusammenführen

Kopf- und Fußzeilen einfügen

Passwortschutz und Sicherheit

Textextraktion

Wasserzeichen hinzufügen

ASP.NET Core-Integration

Async-Unterstützung für Webanwendungen

Dependency Injection Konfiguration

Migration der Fehlerbehandlung

Tipps zur Leistungsoptimierung

Wiederverwendung der Renderer-Instanz

Verwendung von Async in Webanwendungen

Ressourcen richtig entsorgen

Bildkomprimierung

Fehlerbehebung bei allgemeinen Migrationsproblemen

Problem: Unterschiede in der Seitengröße

Problem: Fehlendes CloseOutputFile-Äquivalent

Ausgabe: PDF wird leer wiedergegeben

Problem: CSS/Bilder werden nicht geladen

Post-Migrations-Checkliste

Zukunftssicherheit für Ihre PDF-Lösung

Zusätzliche Ressourcen

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#

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Von Millionen von Ingenieur*innen weltweit vertraut