VIDEOS
Benutzerdefinierte PDF-Wasserzeichen anwenden
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.
Warum sollten Sie einen Wechsel von ActivePDF in Betracht ziehen?
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.
Marken- und Fahrplanüberlegungen
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.
Lizenzierungsmodell
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.
Legacy-Architektur-Muster
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.
Produktlayout mit mehreren SKUs
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.
ActivePDF vs. IronPDF: Hauptunterschiede
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 |
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. 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" .grep -r "using APToolkitNET" --include="*.cs" .
grep -r "using APWebGrabber" --include="*.cs" .
grep -r "ActivePDF" --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 |
|---|---|---|---|
| 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 |
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
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 IronPdf# Remove ActivePDF packages
dotnet remove package ActivePDF.Toolkit
dotnet remove package ActivePDF.WebGrabber
# Install IronPDF
dotnet add package IronPdf
SHELL
Alternativ 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:
<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 APToolkitNET; |
using IronPdf; |
using APWebGrabber; |
using IronPdf; |
APToolkitNET.Toolkit |
ChromePdfRenderer (Rendering) / PdfDocument (Bearbeitung) |
APWebGrabber.WebGrabber |
ChromePdfRenderer |
Komplette API-Migrationsreferenz
Methoden der Dokumentenerstellung
| 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 |
Dateioperationen
| 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 |
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.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) |
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. 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");
}
}
}// 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 Module
$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 IronPDFs ChromePdfRenderer eine Chromium-basierte Rendering-Engine für pixelgenaue CSS- und JavaScript-Unterstützung.
URL zu PDF-Konvertierung
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");
}
}
}// 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 Module
$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 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");
}
}
}
}// 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 Module
$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 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();
}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 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 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();
}
}
}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 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
IronPDFs Sicherheitseinstellungen-API bietet eine granulare Kontrolle über Dokumentberechtigungen mit stark typisierten Enums anstelle von Integer-Flags.
Textextraktion
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();
}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 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 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();
}
}
}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 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 von IronPDF 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 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");
}[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 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:
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}");
}
}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 Using
$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 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");
}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 immer 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 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);' 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)
$vbLabelText
$csharpLabel
Problem: Fehlendes CloseOutputFile-Äquivalent
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 cleanup// 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 cleanupImports ActivePDF
Imports IronPdf
' ActivePDF Toolkit
toolkit.OpenOutputFile(path)
' ... operations ...
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 ordnungsgemäß 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
Zusätzliche Ressourcen
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.
Hinweis:ActivePDF und Apryse sind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit ActivePDF oder Apryse verbunden, unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.
Kostenlos loslegen
Kostenlos loslegen
Kostenlose Live-Demo buchen
