Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. Umstellung von ActivePDF auf IronPDF
MIGRATIONSLEITFäDEN

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

Curtis Chau
Curtis Chau
Aktualisiert:

ActivePDF ist seit langem ein zuverlässiges PDF-Toolkit for .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 ActivePDF zu IronPDF– 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 ActivePDF in Betracht ziehen?

Die Übernahme von ActivePDF durch 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 ActivePDF unter die Eigentümerschaft von Foxit wirft Fragen hinsichtlich der langfristigen Entwicklung des Toolkits auf. Entwickler, die auf ActivePDF angewiesen 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 ActivePDF führt zu Reibungsverlusten in modernen Cloud- und Container-Umgebungen, in denen Anwendungen dynamisch über die Infrastruktur skaliert werden.

Legacy-Architektur-Muster

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

Installations- und Konfigurationsaufwand

Im Gegensatz zur heutigen NuGet-basierten Paketverwaltung erfordert ActivePDF hä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.

ActivePDF vs. IronPDF: Hauptunterschiede

Bevor man mit dem Migrationsprozess beginnt, hilft das Verständnis der grundlegenden Unterschiede zwischen ActivePDF undIronPDF dabei, 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 (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 CloseOutputFile() Direkt SaveAs() Öffnen/Schließen-Aufrufe entfernen
Erstellung der Seite NewPage() 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;
' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Verify license status
Dim isLicensed As Boolean = 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
using ActivePDF.Toolkit; using IronPdf;
using APToolkitNET; using IronPdf;
using APToolkitNET.PDFObjects; using IronPdf;
using APToolkitNET.Common; using IronPdf;

Komplette API-Migrationsreferenz

Methoden der Dokumentenerstellung

ActivePDF-Methode IronPDF-Äquivalent
new Toolkit() new ChromePdfRenderer()
toolkit.OpenOutputFile(path) Kein Äquivalent erforderlich
toolkit.CloseOutputFile() Kein Äquivalent erforderlich
toolkit.AddHTML(html) renderer.RenderHtmlAsPdf(html)
toolkit.AddURL(url) renderer.RenderUrlAsPdf(url)
toolkit.SaveAs(path) pdf.SaveAs(path)

Dateioperationen

ActivePDF-Methode IronPDF-Äquivalent
toolkit.OpenInputFile(path) PdfDocument.FromFile(path)
toolkit.AddPDF(path) PdfDocument.Merge()
toolkit.GetPageCount() pdf.PageCount
toolkit.GetText() pdf.ExtractAllText()

Seitenkonfiguration

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

Sicherheitsmethoden

ActivePDF-Methode IronPDF-Äquivalent
toolkit.Encrypt(password) 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");
        }
    }
}
Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        If toolkit.OpenOutputFile("output.pdf") = 0 Then
            toolkit.AddHTML(htmlContent)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF created successfully")
        End If
    End Sub
End Class
$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");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

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

        Console.WriteLine("PDF created successfully")
    End Sub
End Module
$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 IronPDF's ChromePdfRenderer eine 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");
        }
    }
}
Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        Dim url As String = "https://www.example.com"

        If toolkit.OpenOutputFile("webpage.pdf") = 0 Then
            toolkit.AddURL(url)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF from URL created successfully")
        End If
    End Sub
End Class
$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");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim url As String = "https://www.example.com"

        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Mehrere PDFs zusammenführen

Die Kombination mehrerer PDF-Dokumente zu einer einzigen Datei demonstriert den funktionalen Ansatz vonIronPDF bei 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");
        }
    }
}
Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        If toolkit.OpenOutputFile("merged.pdf") = 0 Then
            toolkit.AddPDF("document1.pdf")
            toolkit.AddPDF("document2.pdf")
            toolkit.CloseOutputFile()
            Console.WriteLine("PDFs merged successfully")
        End If
    End Sub
End Class
$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");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

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

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

        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$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();
    }
}
Imports ActivePDF.Toolkit

Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile(outputPath) = 0 Then
        toolkit.SetHeader("My Document", 12, "Arial")
        toolkit.SetFooter("Page %p of %P", 10, "Arial")
        toolkit.AddHTML(html)
        toolkit.CloseOutputFile()
    End If
End Sub
$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);
}
Imports IronPdf

Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
    Dim renderer = New ChromePdfRenderer()

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

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

    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(outputPath)
    End Using
End Sub
$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();
    }
}
Imports ActivePDF.Toolkit

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        toolkit.Encrypt(password)
        toolkit.SetUserPassword(password)
        toolkit.SetPermissions(4) ' Print only
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
End Sub
$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);
}
Imports IronPdf

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Using 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)
    End Using
End Sub
$vbLabelText   $csharpLabel

IronPDF s 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;
}
Imports ActivePDF.Toolkit

Public Function ExtractText(pdfPath As String) As String
    Dim toolkit As New Toolkit()
    Dim text As String = ""

    If toolkit.OpenInputFile(pdfPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            text &= toolkit.GetTextFromPage(i) & vbCrLf
        Next
        toolkit.CloseInputFile()
    End If

    Return text
End Function
$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();
}
Imports IronPdf

Public Function ExtractText(pdfPath As String) As String
    Using pdf = PdfDocument.FromFile(pdfPath)
        Return pdf.ExtractAllText()
    End Using
End Function
$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();
    }
}
Imports ActivePDF.Toolkit

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            toolkit.SetPage(i)
            toolkit.AddWatermark(watermarkText, 45, 0.5F)
        Next
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
End Sub
$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);
}
Imports IronPdf

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Using pdf = PdfDocument.FromFile(inputPath)
        pdf.ApplyWatermark(
            $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
            rotation:=45,
            opacity:=50)

        pdf.SaveAs(outputPath)
    End Using
End Sub
$vbLabelText   $csharpLabel

Das HTML-basierte Wasserzeichen vonIronPDF ermö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");
}
<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile("temp.pdf") = 0 Then
        toolkit.AddHTML(request.Html)
        toolkit.CloseOutputFile()

        Dim bytes As Byte() = System.IO.File.ReadAllBytes("temp.pdf")
        Return File(bytes, "application/pdf", "report.pdf")
    End If

    Return BadRequest("PDF generation failed")
End Function
$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");
}
<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(request.Html)
        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Using
End Function
$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.IronPDF bietet 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;
}
Imports IronPdf

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
        Return pdf.BinaryData
    End Using
End Function
$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;
    }
}
Imports Microsoft.Extensions.DependencyInjection
Imports System.Threading.Tasks

' Program.vb (.NET 6+)
builder.Services.AddSingleton(Of ChromePdfRenderer)()

' Service wrapper
Public Interface IPdfService
    Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Function GeneratePdfFromUrlAsync(url As String) As Task(Of Byte())
End Interface

Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    End Sub

    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfAsync
        Using pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
            Return pdf.BinaryData
        End Using
    End Function

    Public Async Function GeneratePdfFromUrlAsync(url As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfFromUrlAsync
        Using pdf = Await _renderer.RenderUrlAsPdfAsync(url)
            Return pdf.BinaryData
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Migration der Fehlerbehandlung

ActivePDF verwendet ganzzahlige Rückgabecodes, die Nachschlagetabellen erfordern.IronPDF verwendet 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}");
}
Dim toolkit As New Toolkit()
Dim result As Integer = toolkit.OpenOutputFile(path)

If result <> 0 Then
    ' Error - need to look up error code
    Console.WriteLine($"Error code: {result}")
End If
$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}");
}
Imports IronPdf.Exceptions

Try
    Dim renderer = New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(path)
    End Using
Catch ex As IronPdfProductException
    Console.WriteLine($"IronPDF Error: {ex.Message}")
Catch ex As Exception
    Console.WriteLine($"General Error: {ex.Message}")
End Try
$vbLabelText   $csharpLabel

Tipps zur Leistungsoptimierung

Wiederverwendung der Renderer-Instanz

Das Erstellen eines neuen ChromePdfRenderer verursacht Initialisierungsaufwand. 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");
}
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
For Each html In htmlList
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs($"output_{i}.pdf")
    End Using
Next
$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");
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Public Async Function GenerateReport() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
            Return File(pdf.BinaryData, "application/pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Ressourcen richtig entsorgen

Verwenden Sie stets using Anweisungen, um eine ordnungsgemäße Bereinigung sicherzustellen:

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ährendIronPDF Enums 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);
' 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
' ActivePDF
toolkit.OpenOutputFile(path)
toolkit.AddHTML(html)
toolkit.CloseOutputFile() ' Required!

' IronPDF - no open/close needed
Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs(path) ' 'Using' handles cleanup
End Using
$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");
Dim 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/");
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 SieIronPDF 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. IronPDF s 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 ActivePDF zuIronPDF modernisiert 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
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 ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an