ActivePDF ist seit langem ein zuverlässiges PDF-Toolkit für .NET-Entwickler. Seit der Übernahme von PDFTron im Juni 2020 und der Umbenennung in Apryse im Februar 2023 ist ActivePDF nun als eine von mehreren Marken im erweiterten Apryse-Portfolio eingebracht. Dieses Handbuch bietet einen gründlichen, schrittweisen Migrationspfad von ActivePDF zu IronPDF— einer modernen, aktiv gepflegten .NET-PDF-Bibliothek, die .NET Framework 4.6.2 bis .NET 9 unterstützt.
ActivePDF wird weiterhin geliefert und das ActivePDF.Toolkit NuGet-Paket erhält unter Apryse weiterhin Updates, aber mehrere Aspekte seines Designs und seiner Verpackung können Teams dazu veranlassen, Alternativen zu evaluieren.
ActivePDF ist jetzt eine Marke innerhalb Apryse, neben dem Flaggschiff Apryse SDK. Teams, die sich speziell für ActivePDF aufgrund seines Fokus auf die serverseitige Automatisierung entschieden haben, mögen abwägen, ob sie bei den ActivePDF-SKUs bleiben oder im Laufe der Zeit zum breiteren Apryse SDK wechseln wollen.
Das traditionelle pro-Server/pro-Kern-Lizenzierungsmodell von ActivePDF kann in Cloud- und containerisierten Umgebungen Reibungen verursachen, in denen Anwendungen dynamisch über die Infrastruktur skalieren.
Die API-Oberfläche von ActivePDF spiegelt seine COM/nativen Ursprünge wider. Der CloseOutputFile-Workflow und Ganzzahl-Rückgabewerte (0 für Erfolg) erfordern eine explizite Lebenszyklusverwaltung, die nicht immer mit modernen C#-Idiomen wie using, Ausnahmen und asynchronem Verhalten übereinstimmt.
HTML/URL-zu-PDF-Rendering befindet sich im separaten ActivePDF.WebGrabber Produkt, während die PDF-Bearbeitung in ActivePDF.Toolkit zu finden ist. Ab Toolkit 10 werden die nativen Bibliotheken nicht mehr automatisch in den Systemordner kopiert, daher benötigt der Konstruktor häufig ein explizites CoreLibPath-Argument — ein Muster, das Docker, CI und installationsfreie Bereitstellungen verkomplizieren kann.
Bevor man mit dem Migrationsprozess beginnt, hilft das Verständnis der grundlegenden Unterschiede zwischen ActivePDF und IronPDF dabei, realistische Erwartungen hinsichtlich der erforderlichen Codeänderungen zu formulieren.
| Aspekt | ActivePDF | IronPDF |
|---|---|---|
| Anbieter | Apryse (ehemals PDFTron, übernahm ActivePDF im Juni 2020) | Iron Software, unabhängig |
| Product Layout | Multiple SKUs (Toolkit, WebGrabber, DocConverter, Server, Meridian) | Single IronPdf NuGet package |
| Installation | NuGet-Paket + nativer Laufzeitpfad (CoreLibPath seit v10) | Einzelnes NuGet-Paket; natives bundled |
| API-Muster | Zustandsbehaftet (CloseOutputFile), COM-abgeleitet | Fließende, funktionale API |
| Lizenzmodell | Pro-Server / pro-Kern | Code-basierter Schlüssel |
| .NET-Unterstützung | .NET Framework 4.5+ / .NET Standard 1.0+ / .NET Core | Framework 4.6.2 zu .NET 9 |
| Fehlerbehandlung | Ganzzahlige Rückgabecodes (0 = Erfolg) | Standard .NET Ausnahmen |
| Async-Unterstützung | Nicht nativ | Vollständige Unterstützung von async/await |
Bevor Sie mit der Migration beginnen, sollten Sie die gesamte ActivePDF-Nutzung in Ihrer Lösung identifizieren. Die tatsächlichen Namespaces sind APToolkitNET (Toolkit) und APWebGrabber (WebGrabber); einige Legacy-Projekte verweisen auch auf ActivePDF.Toolkit über die COM-Interop-Assembly. Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus:
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "using APWebGrabber" --include="*.cs" .
grep -r "ActivePDF" --include="*.csproj" .Das Verständnis der grundlegenden API-Unterschiede hilft bei der Planung Ihrer Migrationsstrategie:
| Kategorie | ActivePDF-Verhalten | IronPDF-Verhalten | Migration Aktion |
|---|---|---|---|
| Produkteaufteilung | Toolkit (Manipulation) + WebGrabber (HTML-Rendering) separat verkauft | Einzelnes IronPdf Paket | Beide in eine Bibliothek zusammenführen |
| Objektmodell | APToolkitNET.Toolkit für PDF, APWebGrabber.WebGrabber für HTML | ChromePdfRenderer + PdfDocument | Getrennte Anliegen |
| Dateioperationen | CloseOutputFile() | Direkt SaveAs() | Öffnen/Schließen-Aufrufe entfernen |
| Nativer Laufzeit | CoreLibPath Argument seit v10 | NuGet liefert natives | Pfadkonfiguration 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 |
Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:
Das Paket auf nuget.org ist ActivePDF.Toolkit (aktuelle Version 11.4.4, veröffentlicht im Dezember 2025). HTML-Rendering wird separat als ActivePDF.WebGrabber geliefert. Entfernen Sie die ActivePDF-SKUs und installieren Sie IronPDF:
# Remove ActivePDF packages
dotnet remove package ActivePDF.Toolkit
dotnet remove package ActivePDF.WebGrabber
# Install IronPDF
dotnet add package IronPdfAlternativ kann die Übersetzung auch über die Visual Studio Package Manager Console erfolgen:
Uninstall-Package ActivePDF.Toolkit
Uninstall-Package ActivePDF.WebGrabber
Install-Package IronPdfFür Projekte mit manuellen DLL-Referenzen entfernen Sie die Referenz aus Ihrer .csproj Datei:
<!-- Remove this block -->
<Reference Include="APToolkitNET">
<HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>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.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Verify license status
Dim isLicensed As Boolean = IronPdf.License.IsLicensedFühren Sie ein globales Suchen und Ersetzen in Ihrer Lösung durch:
| Finden Sie | Ersetzen durch |
|---|---|
using APToolkitNET; | using IronPdf; |
using APWebGrabber; | using IronPdf; |
APToolkitNET.Toolkit | ChromePdfRenderer (Rendering) / PdfDocument (Bearbeitung) |
APWebGrabber.WebGrabber | ChromePdfRenderer |
| ActivePDF-Methode | IronPDF-Äquivalent | Notizen |
|---|---|---|
new APToolkitNET.Toolkit() | new ChromePdfRenderer() / new PdfDocument(...) | IronPDF trennt Rendering von der Manipulation |
new Toolkit(CoreLibPath: path) | new ChromePdfRenderer() | NuGet liefert Natives—kein CoreLibPath |
toolkit.OpenOutputFile(path) | Kein Äquivalent erforderlich | Rufen Sie am Ende einfach SaveAs auf |
toolkit.CloseOutputFile() | Kein Äquivalent erforderlich | using übernimmt die Bereinigung |
webGrabber.URL = html; webGrabber.ConvertToPDF() | renderer.RenderHtmlAsPdf(html) | WebGrabber, nicht Toolkit |
webGrabher.URL = url; webGrabber.ConvertToPDF() | renderer.RenderUrlAsPdf(url) | WebGrabber, nicht Toolkit |
| ActivePDF-Methode | IronPDF-Äquivalent | Notizen |
|---|---|---|
toolkit.OpenInputFile(path) | PdfDocument.FromFile(path) | Vorhandene PDF-Datei laden |
toolkit.MergeFile(path, startPage, endPage) | PdfDocument.Merge(pdfs) | ActivePDF fügt in das offene Ausgabedokument direkt ein;IronPDF gibt ein neues zusammengeführtes Dokument zurück |
toolkit.NumPages (Eigenschaft) | pdf.PageCount | Anzahl der Seiten |
toolkit.GetPageText(page, 0) | pdf.Pages[i].Text / pdf.ExtractAllText() | Textextraktion |
| 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 |
| ActivePDF-Methode | IronPDF-Äquivalent |
|---|---|
toolkit.SetEncryption(user, owner, 128, 0) | pdf.SecuritySettings.OwnerPassword / UserPassword |
toolkit.SetPermissions(flags) | pdf.SecuritySettings.AllowUserXxx |
toolkit.PrintText(x, y, text) (pro Seite Wasserzeichen) | pdf.ApplyWatermark(html) |
Die Konvertierung von HTML-Strings in PDF-Dokumente ist eines der häufigsten Szenarien für die PDF-Erstellung. Beachten Sie, dass in ActivePDF, HTML-Rendering in das separat lizenzierte WebGrabber-Produkt lebt, nicht im Toolkit, und WebGrabber von einer URL oder einem Dateipfad rendert, statt von einer In-Memory-Zeichenfolge.
ActivePDF Implementation (WebGrabber):
// NuGet: Install-Package ActivePDF.WebGrabber
using APWebGrabber;
using System;
using System.IO;
class Program
{
static void Main()
{
WebGrabber wg = new WebGrabber();
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
string tempHtml = Path.Combine(Path.GetTempPath(), "input.html");
File.WriteAllText(tempHtml, htmlContent);
wg.URL = tempHtml;
wg.OutputDirectory = Directory.GetCurrentDirectory();
wg.OutputFilename = "output.pdf";
if (wg.ConvertToPDF() == 0)
{
Console.WriteLine("PDF created successfully");
}
}
}Imports APWebGrabber
Imports System
Imports System.IO
Module Program
Sub Main()
Dim wg As New WebGrabber()
Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
Dim tempHtml As String = Path.Combine(Path.GetTempPath(), "input.html")
File.WriteAllText(tempHtml, htmlContent)
wg.URL = tempHtml
wg.OutputDirectory = Directory.GetCurrentDirectory()
wg.OutputFilename = "output.pdf"
If wg.ConvertToPDF() = 0 Then
Console.WriteLine("PDF created successfully")
End If
End Sub
End ModuleIronPDF-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
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 ModuleMit 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 IronPDFs ChromePdfRenderer eine Chromium-basierte Rendering-Engine für pixelgenaue CSS- und JavaScript-Unterstützung.
Das Erfassen von Webseiten als PDF-Dokumente lebt auch in WebGrabber, nicht im Toolkit.
ActivePDF Implementation (WebGrabber):
// NuGet: Install-Package ActivePDF.WebGrabber
using APWebGrabber;
using System;
using System.IO;
class Program
{
static void Main()
{
WebGrabber wg = new WebGrabber();
wg.URL = "https://www.example.com";
wg.OutputDirectory = Directory.GetCurrentDirectory();
wg.OutputFilename = "webpage.pdf";
if (wg.ConvertToPDF() == 0)
{
Console.WriteLine("PDF from URL created successfully");
}
}
}Imports APWebGrabber
Imports System
Imports System.IO
Module Program
Sub Main()
Dim wg As New WebGrabber()
wg.URL = "https://www.example.com"
wg.OutputDirectory = Directory.GetCurrentDirectory()
wg.OutputFilename = "webpage.pdf"
If wg.ConvertToPDF() = 0 Then
Console.WriteLine("PDF from URL created successfully")
End If
End Sub
End ModuleIronPDF-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");
}
}Imports IronPdf
Imports System
Module Program
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 ModuleDie Kombination mehrerer PDF-Dokumente zu einer einzigen Datei demonstriert den funktionalen Ansatz von IronPDF bei der Dokumentenmanipulation.
ActivePDF Implementation (Toolkit):
// NuGet: Install-Package ActivePDF.Toolkit
using APToolkitNET;
using System;
class Program
{
static void Main()
{
using (Toolkit toolkit = new Toolkit())
{
if (toolkit.OpenOutputFile("merged.pdf") == 0)
{
// MergeFile(FileName, StartPage, EndPage); -1 = end of file
toolkit.MergeFile("document1.pdf", 1, -1);
toolkit.MergeFile("document2.pdf", 1, -1);
toolkit.CloseOutputFile();
Console.WriteLine("PDFs merged successfully");
}
}
}
}Imports APToolkitNET
Imports System
Module Program
Sub Main()
Using toolkit As New Toolkit()
If toolkit.OpenOutputFile("merged.pdf") = 0 Then
' MergeFile(FileName, StartPage, EndPage); -1 = end of file
toolkit.MergeFile("document1.pdf", 1, -1)
toolkit.MergeFile("document2.pdf", 1, -1)
toolkit.CloseOutputFile()
Console.WriteLine("PDFs merged successfully")
End If
End Using
End Sub
End ModuleIronPDF-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");
}
}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 ModuleWeitere fortgeschrittene Zusammenführungsszenarien, einschließlich der selektiven Seitenextraktion, finden Sie in der PDF-Zusammenführungsdokumentation.
ActivePDF Implementation (WebGrabber):
using APWebGrabber;
using System.IO;
public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
var wg = new WebGrabber();
string tempHtml = Path.Combine(Path.GetTempPath(), "input.html");
File.WriteAllText(tempHtml, html);
wg.URL = tempHtml;
wg.HeaderText = "My Document";
wg.FooterText = "Page [page] of [pages]";
wg.OutputDirectory = Path.GetDirectoryName(outputPath);
wg.OutputFilename = Path.GetFileName(outputPath);
wg.ConvertToPDF();
}Imports APWebGrabber
Imports System.IO
Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
Dim wg As New WebGrabber()
Dim tempHtml As String = Path.Combine(Path.GetTempPath(), "input.html")
File.WriteAllText(tempHtml, html)
wg.URL = tempHtml
wg.HeaderText = "My Document"
wg.FooterText = "Page [page] of [pages]"
wg.OutputDirectory = Path.GetDirectoryName(outputPath)
wg.OutputFilename = Path.GetFileName(outputPath)
wg.ConvertToPDF()
End SubIronPDF-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);
}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 SubIronPDF unterstützt sowohl textbasierte als auch HTML-Kopf- und -Fußzeilen und bietet somit vollständige Flexibilität bei der Gestaltung.
ActivePDF Implementation (Toolkit):
using APToolkitNET;
public void ProtectPdf(string inputPath, string outputPath, string password)
{
using (Toolkit toolkit = new Toolkit())
{
if (toolkit.OpenOutputFile(outputPath) == 0
&& toolkit.OpenInputFile(inputPath) == 0)
{
toolkit.SetEncryption(password, password, 128, 0);
toolkit.CopyForm(0, 0);
toolkit.CloseInputFile();
toolkit.CloseOutputFile();
}
}
}Imports APToolkitNET
Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
Using toolkit As New Toolkit()
If toolkit.OpenOutputFile(outputPath) = 0 AndAlso toolkit.OpenInputFile(inputPath) = 0 Then
toolkit.SetEncryption(password, password, 128, 0)
toolkit.CopyForm(0, 0)
toolkit.CloseInputFile()
toolkit.CloseOutputFile()
End If
End Using
End SubIronPDF-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);
}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 SubIronPDFs Sicherheitseinstellungen-API bietet eine granulare Kontrolle über Dokumentberechtigungen mit stark typisierten Enums anstelle von Integer-Flags.
ActivePDF Implementation (Toolkit):
using APToolkitNET;
using System.Text;
public string ExtractText(string pdfPath)
{
var sb = new StringBuilder();
using (Toolkit toolkit = new Toolkit())
{
if (toolkit.OpenInputFile(pdfPath) == 0)
{
int pageCount = toolkit.NumPages;
for (int i = 1; i <= pageCount; i++)
{
sb.AppendLine(toolkit.GetPageText(i, 0));
}
toolkit.CloseInputFile();
}
}
return sb.ToString();
}Imports APToolkitNET
Imports System.Text
Public Function ExtractText(pdfPath As String) As String
Dim sb As New StringBuilder()
Using toolkit As New Toolkit()
If toolkit.OpenInputFile(pdfPath) = 0 Then
Dim pageCount As Integer = toolkit.NumPages
For i As Integer = 1 To pageCount
sb.AppendLine(toolkit.GetPageText(i, 0))
Next
toolkit.CloseInputFile()
End If
End Using
Return sb.ToString()
End FunctionIronPDF-Implementierung:
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 FunctionDie IronPDF-Implementierung reduziert die Textextraktion aus mehreren Zeilen auf einen einzigen Methodenaufruf.
ActivePDF Implementierung (Toolkit — als Seitentext pro Seite gezeichnet):
using APToolkitNET;
public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
using (Toolkit toolkit = new Toolkit())
{
if (toolkit.OpenOutputFile(outputPath) == 0
&& toolkit.OpenInputFile(inputPath) == 0)
{
int pageCount = toolkit.NumPages;
for (int i = 1; i <= pageCount; i++)
{
toolkit.CopyForm(i, 0);
toolkit.SetFont("Helvetica", 72);
toolkit.SetTextColor(200, 200, 200);
toolkit.PrintText(150, 400, watermarkText);
}
toolkit.CloseInputFile();
toolkit.CloseOutputFile();
}
}
}Imports APToolkitNET
Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
Using toolkit As New Toolkit()
If toolkit.OpenOutputFile(outputPath) = 0 AndAlso toolkit.OpenInputFile(inputPath) = 0 Then
Dim pageCount As Integer = toolkit.NumPages
For i As Integer = 1 To pageCount
toolkit.CopyForm(i, 0)
toolkit.SetFont("Helvetica", 72)
toolkit.SetTextColor(200, 200, 200)
toolkit.PrintText(150, 400, watermarkText)
Next
toolkit.CloseInputFile()
toolkit.CloseOutputFile()
End If
End Using
End SubIronPDF-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);
}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 SubDas HTML-basierte Wasserzeichen von IronPDF ermöglicht CSS-Styling für eine vollständige Designkontrolle ohne seitenweise Iteration.
Moderne Webanwendungen profitieren erheblich von den sauberen Integrationsmustern von IronPDF.
ActivePDF Pattern (WebGrabber):
[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
var wg = new APWebGrabber.WebGrabber();
string tempHtml = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".html");
System.IO.File.WriteAllText(tempHtml, request.Html);
wg.URL = tempHtml;
wg.OutputDirectory = Path.GetTempPath();
wg.OutputFilename = "temp.pdf";
if (wg.ConvertToPDF() == 0)
{
byte[] bytes = System.IO.File.ReadAllBytes(Path.Combine(Path.GetTempPath(), "temp.pdf"));
return File(bytes, "application/pdf", "report.pdf");
}
return BadRequest("PDF generation failed");
}Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc
<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
Dim wg As New APWebGrabber.WebGrabber()
Dim tempHtml As String = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() & ".html")
System.IO.File.WriteAllText(tempHtml, request.Html)
wg.URL = tempHtml
wg.OutputDirectory = Path.GetTempPath()
wg.OutputFilename = "temp.pdf"
If wg.ConvertToPDF() = 0 Then
Dim bytes As Byte() = System.IO.File.ReadAllBytes(Path.Combine(Path.GetTempPath(), "temp.pdf"))
Return File(bytes, "application/pdf", "report.pdf")
End If
Return BadRequest("PDF generation failed")
End FunctionIronPDF-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 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 FunctionIronPDF macht temporäre Dateien überflüssig und gibt die PDF-Binärdaten direkt aus dem Speicher zurück.
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;
}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 FunctionFü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;
}
}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 ClassActivePDF verwendet ganzzahlige Rückgabecodes, die Nachschlagetabellen erfordern.IronPDF verwendet eine moderne Ausnahmebehandlung:
ActivePDF-Fehlerbehandlung:
using APToolkitNET;
using (var toolkit = new Toolkit())
{
int result = toolkit.OpenOutputFile(path);
if (result != 0)
{
// Error - look up the code in "Toolkit Return Results and Error Codes"
Console.WriteLine($"Error code: {result}");
}
}Imports APToolkitNET
Using toolkit As New Toolkit()
Dim result As Integer = toolkit.OpenOutputFile(path)
If result <> 0 Then
' Error - look up the code in "Toolkit Return Results and Error Codes"
Console.WriteLine($"Error code: {result}")
End If
End UsingIronPDF-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}");
}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 TryDas Erstellen eines neuen ChromePdfRenderer hat einen 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");
}Imports IronPdf
Dim renderer As New ChromePdfRenderer()
For Each html In htmlList
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"output_{i}.pdf")
End Using
NextBei 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");
}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 ClassVerwenden Sie immer using Anweisungen, um eine ordnungsgemäße Bereinigung sicherzustellen:
using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;netReduzieren Sie die Größe der Ausgabedatei mit Bildkomprimierung:
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");netActivePDF WebGrabber verwendet Points (612x792 = Brief), während IronPDF Enums oder Millimeter verwendet:
// ActivePDF WebGrabber: Points
wg.PageWidth = 612;
wg.PageHeight = 792;
// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);' ActivePDF WebGrabber: Points
wg.PageWidth = 612
wg.PageHeight = 792
' IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4)IronPDF verwendet ein modernes Paradigma ohne explizites Dateihandle-Management:
// ActivePDF Toolkit
toolkit.OpenOutputFile(path);
// ... operations ...
toolkit.CloseOutputFile(); // Required!
//IronPDF- no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanupWenn 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");Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.RenderDelay(2000)
' Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")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/")Überprüfen Sie nach Abschluss der Codemigration Folgendes:
IronPdf.License.IsLicensed)Die Migration von ActivePDF zu IronPDF 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 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 Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
