MIGRATIONSLEITFäDEN
Umstellung von Adobe PDF Library SDK auf IronPDF
Das Adobe PDF Library SDK, erhältlich über Datalogics, bietet die authentische Adobe PDF-Engine mit erweiterten Funktionen. Die hohen Lizenzkosten, die komplexe native SDK-Integration und das Low-Level-API-Design machen es jedoch für viele Entwicklungsteams unpraktisch. Dieser Leitfaden bietet eine schrittweise Anleitung zur Migration vom Adobe PDF Library SDK zu IronPDF– einer modernen, kostengünstigen .NET PDF-Bibliothek, die .NET Framework 4.6.2 bis .NET 9 und zukünftige Versionen unterstützt.
Warum sollten Sie einen Wechsel weg vom Adobe PDF Library SDK in Betracht ziehen?
Obwohl das Adobe PDF Library SDK die originale Adobe PDF-Engine bietet, veranlassen verschiedene Faktoren die Entwicklungsteams dazu, Alternativen für ihre Anforderungen an die PDF-Erstellung und -Bearbeitung zu suchen.
Hohe Lizenzkosten
Das Adobe PDF Library SDK wird zu Preisen angeboten, die im Enterprise Bereich angesiedelt sind und typischerweise zwischen 10.000 und über 50.000 US-Dollar pro Jahr liegen. Diese Kostenstruktur macht das SDK für kleine und mittelständische Unternehmen, Startups, einzelne Entwickler und Projekte, bei denen die volle Funktionalität der Adobe-Engine nicht erforderlich ist, unpraktisch.
Komplexe Native SDK-Integration
Das Adobe PDF Library SDK basiert auf nativem C++-Code und benötigt plattformspezifische Binärdateien. Entwickler müssen den Speicher sorgfältig verwalten, explizite Initialisierungs- und Beendigungsmuster handhaben und komplizierte Einrichtungsprozeduren durchlaufen. Dies führt zu einem erheblichen Mehraufwand bei der Entwicklung und erschwert CI/CD-Pipelines.
Low-Level-API-Design
Die Erstellung von PDFs mit dem Adobe PDF Library SDK beinhaltet das programmgesteuerte Konstruieren von Seiten, Inhaltsströmen, Textabschnitten und Schriftarten. Einfache Aufgaben wie das Rendern von HTML-Inhalten werden zu mehrstufigen Operationen, die Koordinatenberechnungen, das Einbetten von Schriften und die manuelle Verwaltung von Inhaltselementen umfassen.
Aufwand für die Verwaltung des Lebenszyklus von Bibliotheken
Jeder Vorgang erfordert das Einschließen von Code in Library.Initialize() und Library.Terminate() Blöcke mit sorgfältiger Entsorgung der COM-Objekte. Das Vergessen von Bereinigungsschritten führt zu Ressourcenlecks und Instabilität der Anwendung.
Overkill für typische Projekte
Für Anwendungen, die in erster Linie die Konvertierung von HTML in PDF, die grundlegende Bearbeitung von Dokumenten oder die Erstellung von Berichten erfordern, stellt die vollständige Adobe PDF-Engine ein erhebliches Over-Engineering dar, während einfachere Lösungen gleichwertige Ergebnisse liefern.
Adobe PDF Library SDK vs. IronPDF: Hauptunterschiede
Das Verständnis der grundlegenden architektonischen Unterschiede zwischen diesen Bibliotheken hilft bei der Planung einer effektiven Migrationsstrategie.
| Aspekt | Adobe PDF Library SDK | IronPDF |
|---|---|---|
| Preisgestaltung | $10K-$50K+/Jahr Unternehmen | Erschwingliche Lizenzierung pro Entwickler |
| Installation | Native DLLs, plattformspezifisch | Einfaches NuGet-Paket |
| Dokumentenerstellung | Aufbau von Seiten/Inhalten auf niedriger Ebene | HTML/CSS-Rendering |
| Initialisierung | Terminate() erforderlich |
Automatisch |
| Koordinatensystem | PostScript-Punkte, Ursprung unten links | CSS-basiertes Layout |
| Schriftbehandlung | Manuelle Einbettung erforderlich | Automatisch |
| Speichermanagement | Manuelle Entsorgung von COM-Objekten | Standard IDisposable-Muster |
| Async-Unterstützung | Nicht verfügbar | Vollständige Unterstützung von async/await |
Vorbereitung auf die Migration
Voraussetzungen
Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt, bevor Sie mit der Migration beginnen:
- .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)
Audit der Verwendung von Adobe PDF Library SDK
Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus, um alle Verweise auf Adobe PDF Library SDK zu identifizieren:
grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .
SHELL
Bahnbrechende Änderungen, die zu erwarten sind
| Kategorie | Adobe PDF Library SDK | IronPDF | Migration Aktion |
|---|---|---|---|
| Initialisierung | Library.Initialize() / Terminate() |
Automatisch | Lebenszyklus-Code entfernen |
| Erstellung des Dokuments | new Document() mit Seitenkonstruktion |
ChromePdfRenderer |
HTML-Rendering verwenden |
| Koordinatensystem | PostScript-Punkte, Ursprung unten links | CSS-basiertes Layout | HTML/CSS verwenden |
| Handhabung von Schriftarten | Manuelle Erstellung und Einbettung von Font |
Automatisch | Schriftcode entfernen |
| Speicherverwaltung | Manuelle Entsorgung von COM-Objekten | Standard IDisposable | Verwenden Sie using Anweisungen |
| Aufbau der Seite | CreatePage(), AddContent() |
Automatisch aus HTML | Deutlich vereinfachen |
Schritt-für-Schritt-Migrationsprozess
Schritt 1: NuGet-Pakete aktualisieren
Entfernen Sie das Paket Adobe PDF Library SDK und installieren Sie IronPDF:
# Remove Adobe PDF Library
dotnet remove package Adobe.PDF.Library.LM.NET
# Install IronPDF
dotnet add package IronPdf# Remove Adobe PDF Library
dotnet remove package Adobe.PDF.Library.LM.NET
# Install IronPDF
dotnet add package IronPdf
SHELL
Schritt 2: Konfigurieren des Lizenzschlüssels
Ersetzen Sie die Lizenzierung von Adobe durch den codebasierten Lizenzschlüssel von IronPDF:
// Replace Adobe's Library.LicenseKey withIronPDFlicense
// Add at application startup, before anyIronPDFoperations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;// Replace Adobe's Library.LicenseKey withIronPDFlicense
// Add at application startup, before anyIronPDFoperations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;' Replace Adobe's Library.LicenseKey with IronPDF license
' Add at application startup, before any IronPDF operations
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 Datalogics.PDFL; |
using IronPdf; |
using Datalogics.PDFL.Document; |
using IronPdf; |
using Datalogics.PDFL.Page; |
using IronPdf; |
using Datalogics.PDFL.Content; |
using IronPdf; |
Schritt 4: Code aus dem Lebenszyklus der Bibliothek entfernen
Eine der wichtigsten Vereinfachungen ist das Entfernen von Initialisierungs- und Beendigungsmustern:
// Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize();
try
{
// PDF operations
}
finally
{
Library.Terminate(); // Must always terminate
}
//IronPDF- Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);// Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize();
try
{
// PDF operations
}
finally
{
Library.Terminate(); // Must always terminate
}
//IronPDF- Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);Imports AdobePDFLibrary
Imports IronPdf
' Adobe PDF Library SDK- REMOVE THIS PATTERN
Library.Initialize()
Try
' PDF operations
Finally
Library.Terminate() ' Must always terminate
End Try
' IronPDF- Just use directly
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText
$csharpLabel
Komplette API-Migrationsreferenz
Bibliotheks-Lebenszyklus-Methoden
| Adobe-Methode | IronPDF-Äquivalent |
|---|---|
Library.Initialize() |
Nicht erforderlich |
Library.Terminate() |
Nicht erforderlich |
Library.LicenseKey = "KEY" |
IronPdf.License.LicenseKey = "KEY" |
using (Library lib = new Library()) |
Nicht erforderlich |
Methoden der Dokumentenerstellung
| Adobe-Methode | IronPDF-Methode |
|---|---|
new Document() |
new ChromePdfRenderer() |
new Document(path) |
PdfDocument.FromFile(path) |
doc.CreatePage(index, rect) |
Automatisch aus HTML |
doc.Save(SaveFlags.Full, path) |
pdf.SaveAs(path) |
doc.NumPages |
pdf.PageCount |
doc.GetPage(index) |
pdf.Pages[index] |
doc.InsertPages(...) |
PdfDocument.Merge() |
Inhaltserstellung (großer Paradigmenwechsel)
Adobe PDF Library SDK erfordert die Erstellung von Inhalten auf niedriger Ebene.IronPDF verwendet HTML/CSS:
| Adobe-Methode | IronPDF-Methode |
|---|---|
new Text() |
Verwenden Sie HTML <p>, <h1>, etc. |
text.AddRun(textRun) |
HTML verwenden |
new TextRun(text, font, size, point) |
CSS-Styling |
new Font(name, flags) |
CSS font-family |
new Image(path) |
HTML <img> Tag |
content.AddElement(...) |
HTML-Inhalt |
page.UpdateContent() |
Nicht erforderlich |
Wasserzeichen und Sicherheitsmethoden
| Adobe-Methode | IronPDF-Methode |
|---|---|
new Watermark(doc, textParams, wmParams) |
pdf.ApplyWatermark(html) |
WatermarkParams.Opacity |
CSS opacity |
new EncryptionHandler(user, owner, perms) |
pdf.SecuritySettings |
PermissionFlags.PrintDoc |
AllowUserPrinting |
Textextraktion
| Adobe-Methode | IronPDF-Methode |
|---|---|
new WordFinder(doc, config) |
pdf.ExtractAllText() |
wordFinder.GetWordList() |
pdf.Pages[i].Text |
| Komplexe Wort-/Zeichenwiederholung | Einzelner Methodenaufruf |
Beispiele für die Code-Migration
HTML-zu-PDF-Konvertierung
Die stärkste Vereinfachung tritt bei der Konvertierung von Inhalten in PDF auf. Adobe PDF Library SDK erfordert die manuelle Erstellung von Seiten, die Einbettung von Schriften und die Positionierung von Koordinaten.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeHtmlToPdf
{
static void Main()
{
using (Library lib = new Library())
{
// Adobe PDF Library requires complex setup with HTML conversion parameters
HTMLConversionParameters htmlParams = new HTMLConversionParameters();
htmlParams.PaperSize = PaperSize.Letter;
htmlParams.Orientation = Orientation.Portrait;
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
// Convert HTML to PDF
Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
doc.Save(SaveFlags.Full, "output.pdf");
doc.Dispose();
}
}
}// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeHtmlToPdf
{
static void Main()
{
using (Library lib = new Library())
{
// Adobe PDF Library requires complex setup with HTML conversion parameters
HTMLConversionParameters htmlParams = new HTMLConversionParameters();
htmlParams.PaperSize = PaperSize.Letter;
htmlParams.Orientation = Orientation.Portrait;
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
// Convert HTML to PDF
Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
doc.Save(SaveFlags.Full, "output.pdf");
doc.Dispose();
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeHtmlToPdf
Shared Sub Main()
Using lib As New Library()
' Adobe PDF Library requires complex setup with HTML conversion parameters
Dim htmlParams As New HTMLConversionParameters()
htmlParams.PaperSize = PaperSize.Letter
htmlParams.Orientation = Orientation.Portrait
Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
' Convert HTML to PDF
Dim doc As Document = Document.CreateFromHTML(htmlContent, htmlParams)
doc.Save(SaveFlags.Full, "output.pdf")
doc.Dispose()
End Using
End Sub
End Class
$vbLabelText
$csharpLabel
IronPDF-Implementierung:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfHtmlToPdf
{
static void Main()
{
var renderer = new ChromePdfRenderer();
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
// Convert HTML to PDF with simple API
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfHtmlToPdf
{
static void Main()
{
var renderer = new ChromePdfRenderer();
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
// Convert HTML to PDF with simple API
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports System
Class IronPdfHtmlToPdf
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
' Convert HTML to PDF with simple API
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")
End Sub
End Class
$vbLabelText
$csharpLabel
IronPDF macht den Library Lifecycle Wrapper, die Konvertierungsparameterobjekte und die explizite Entsorgung überflüssig. Der ChromePdfRenderer verwendet eine Chromium-basierte Engine für pixelgenaue CSS- und JavaScript Unterstützung. Für fortgeschrittene Szenarien siehe die HTML zu PDF Dokumentation.
Mehrere PDFs zusammenführen
Die PDF-Zusammenführung zeigt den Unterschied in der API-Komplexität deutlich auf.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeMergePdfs
{
static void Main()
{
using (Library lib = new Library())
{
// Open first PDF document
Document doc1 = new Document("document1.pdf");
Document doc2 = new Document("document2.pdf");
// Insert pages from second document into first
PageInsertParams insertParams = new PageInsertParams();
insertParams.InsertFlags = PageInsertFlags.None;
for (int i = 0; i < doc2.NumPages; i++)
{
Page page = doc2.GetPage(i);
doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
}
doc1.Save(SaveFlags.Full, "merged.pdf");
doc1.Dispose();
doc2.Dispose();
}
}
}// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeMergePdfs
{
static void Main()
{
using (Library lib = new Library())
{
// Open first PDF document
Document doc1 = new Document("document1.pdf");
Document doc2 = new Document("document2.pdf");
// Insert pages from second document into first
PageInsertParams insertParams = new PageInsertParams();
insertParams.InsertFlags = PageInsertFlags.None;
for (int i = 0; i < doc2.NumPages; i++)
{
Page page = doc2.GetPage(i);
doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
}
doc1.Save(SaveFlags.Full, "merged.pdf");
doc1.Dispose();
doc2.Dispose();
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeMergePdfs
Shared Sub Main()
Using lib As New Library()
' Open first PDF document
Dim doc1 As New Document("document1.pdf")
Dim doc2 As New Document("document2.pdf")
' Insert pages from second document into first
Dim insertParams As New PageInsertParams()
insertParams.InsertFlags = PageInsertFlags.None
For i As Integer = 0 To doc2.NumPages - 1
Dim page As Page = doc2.GetPage(i)
doc1.InsertPage(doc1.NumPages - 1, page, insertParams)
Next
doc1.Save(SaveFlags.Full, "merged.pdf")
doc1.Dispose()
doc2.Dispose()
End Using
End Sub
End Class
$vbLabelText
$csharpLabel
IronPDF-Implementierung:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfMergePdfs
{
static void Main()
{
// Load PDF documents
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
// Merge PDFs with simple method
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfMergePdfs
{
static void Main()
{
// Load PDF documents
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
// Merge PDFs with simple method
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}Imports IronPdf
Imports System
Class IronPdfMergePdfs
Shared Sub Main()
' Load PDF documents
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
' Merge PDFs with simple method
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")
End Sub
End Class
$vbLabelText
$csharpLabel
Der Ansatz von Adobe erfordert eine seitenweise Iteration mit Einfügeparametern.IronPDF bietet eine einzige Merge Methode, die mehrere Dokumente akzeptiert.
Wasserzeichen hinzufügen
Das Wasserzeichen veranschaulicht, wieIronPDF HTML/CSS für die flexible Gestaltung nutzt.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeAddWatermark
{
static void Main()
{
using (Library lib = new Library())
{
Document doc = new Document("input.pdf");
// Create watermark with complex API
WatermarkParams watermarkParams = new WatermarkParams();
watermarkParams.Opacity = 0.5;
watermarkParams.Rotation = 45.0;
watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;
WatermarkTextParams textParams = new WatermarkTextParams();
textParams.Text = "CONFIDENTIAL";
Watermark watermark = new Watermark(doc, textParams, watermarkParams);
doc.Save(SaveFlags.Full, "watermarked.pdf");
doc.Dispose();
}
}
}// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;
class AdobeAddWatermark
{
static void Main()
{
using (Library lib = new Library())
{
Document doc = new Document("input.pdf");
// Create watermark with complex API
WatermarkParams watermarkParams = new WatermarkParams();
watermarkParams.Opacity = 0.5;
watermarkParams.Rotation = 45.0;
watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;
WatermarkTextParams textParams = new WatermarkTextParams();
textParams.Text = "CONFIDENTIAL";
Watermark watermark = new Watermark(doc, textParams, watermarkParams);
doc.Save(SaveFlags.Full, "watermarked.pdf");
doc.Dispose();
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeAddWatermark
Shared Sub Main()
Using lib As New Library()
Dim doc As New Document("input.pdf")
' Create watermark with complex API
Dim watermarkParams As New WatermarkParams()
watermarkParams.Opacity = 0.5
watermarkParams.Rotation = 45.0
watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center
watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center
Dim textParams As New WatermarkTextParams()
textParams.Text = "CONFIDENTIAL"
Dim watermark As New Watermark(doc, textParams, watermarkParams)
doc.Save(SaveFlags.Full, "watermarked.pdf")
doc.Dispose()
End Using
End Sub
End Class
$vbLabelText
$csharpLabel
IronPDF-Implementierung:
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;
class IronPdfAddWatermark
{
static void Main()
{
var pdf = PdfDocument.FromFile("input.pdf");
// Apply text watermark with simple API
pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
rotation: 45,
verticalAlignment: VerticalAlignment.Middle,
horizontalAlignment: HorizontalAlignment.Center);
pdf.SaveAs("watermarked.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;
class IronPdfAddWatermark
{
static void Main()
{
var pdf = PdfDocument.FromFile("input.pdf");
// Apply text watermark with simple API
pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
rotation: 45,
verticalAlignment: VerticalAlignment.Middle,
horizontalAlignment: HorizontalAlignment.Center);
pdf.SaveAs("watermarked.pdf");
}
}Imports IronPdf
Imports IronPdf.Editing
Imports System
Class IronPdfAddWatermark
Shared Sub Main()
Dim pdf = PdfDocument.FromFile("input.pdf")
' Apply text watermark with simple API
pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
rotation:=45,
verticalAlignment:=VerticalAlignment.Middle,
horizontalAlignment:=HorizontalAlignment.Center)
pdf.SaveAs("watermarked.pdf")
End Sub
End Class
$vbLabelText
$csharpLabel
Das HTML-basierte Wasserzeichen vonIronPDF bietet vollständige Designkontrolle durch CSS-Styling und macht separate Parameterobjekte überflüssig.
Passwortschutz und Verschlüsselung
Adobe PDF Library SDK Implementierung:
using Datalogics.PDFL;
public void ProtectPdf(string inputPath, string outputPath, string password)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
PermissionFlags permissions =
PermissionFlags.PrintDoc |
PermissionFlags.PrintFidelity;
EncryptionHandler encHandler = new EncryptionHandler(
password, // User password
password, // Owner password
permissions,
EncryptionMethod.AES256);
doc.SetEncryptionHandler(encHandler);
doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
}
}
finally
{
Library.Terminate();
}
}using Datalogics.PDFL;
public void ProtectPdf(string inputPath, string outputPath, string password)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
PermissionFlags permissions =
PermissionFlags.PrintDoc |
PermissionFlags.PrintFidelity;
EncryptionHandler encHandler = new EncryptionHandler(
password, // User password
password, // Owner password
permissions,
EncryptionMethod.AES256);
doc.SetEncryptionHandler(encHandler);
doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
}
}
finally
{
Library.Terminate();
}
}Imports Datalogics.PDFL
Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
Library.Initialize()
Try
Using doc As New Document(inputPath)
Dim permissions As PermissionFlags = PermissionFlags.PrintDoc Or PermissionFlags.PrintFidelity
Dim encHandler As New EncryptionHandler(
password, ' User password
password, ' Owner password
permissions,
EncryptionMethod.AES256)
doc.SetEncryptionHandler(encHandler)
doc.Save(SaveFlags.Full Or SaveFlags.Encrypted, outputPath)
End Using
Finally
Library.Terminate()
End Try
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.UserPassword = password;
pdf.SecuritySettings.OwnerPassword = 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.UserPassword = password;
pdf.SecuritySettings.OwnerPassword = 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.UserPassword = password
pdf.SecuritySettings.OwnerPassword = 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 verwendet stark typisierte Eigenschaften anstelle von bitweisen Berechtigungsflags und Verschlüsselungshandler-Objekten.
Textextraktion
Adobe PDF Library SDK Implementierung:
using Datalogics.PDFL;
public string ExtractText(string pdfPath)
{
string extractedText = "";
Library.Initialize();
try
{
using (Document doc = new Document(pdfPath))
{
WordFinderConfig config = new WordFinderConfig();
config.IgnoreCharGaps = true;
for (int i = 0; i < doc.NumPages; i++)
{
using (WordFinder wordFinder = new WordFinder(doc, i, config))
{
IList<Word> words = wordFinder.GetWordList();
foreach (Word word in words)
{
extractedText += word.Text + " ";
}
extractedText += "\n";
}
}
}
}
finally
{
Library.Terminate();
}
return extractedText;
}using Datalogics.PDFL;
public string ExtractText(string pdfPath)
{
string extractedText = "";
Library.Initialize();
try
{
using (Document doc = new Document(pdfPath))
{
WordFinderConfig config = new WordFinderConfig();
config.IgnoreCharGaps = true;
for (int i = 0; i < doc.NumPages; i++)
{
using (WordFinder wordFinder = new WordFinder(doc, i, config))
{
IList<Word> words = wordFinder.GetWordList();
foreach (Word word in words)
{
extractedText += word.Text + " ";
}
extractedText += "\n";
}
}
}
}
finally
{
Library.Terminate();
}
return extractedText;
}Imports Datalogics.PDFL
Public Function ExtractText(ByVal pdfPath As String) As String
Dim extractedText As String = ""
Library.Initialize()
Try
Using doc As New Document(pdfPath)
Dim config As New WordFinderConfig()
config.IgnoreCharGaps = True
For i As Integer = 0 To doc.NumPages - 1
Using wordFinder As New WordFinder(doc, i, config)
Dim words As IList(Of Word) = wordFinder.GetWordList()
For Each word As Word In words
extractedText &= word.Text & " "
Next
extractedText &= vbLf
End Using
Next
End Using
Finally
Library.Terminate()
End Try
Return extractedText
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 Wort-für-Wort-Iteration von Adobe wird mitIronPDF zu einem einzigen Methodenaufruf.
Kopf- und Fußzeilen
Adobe PDF Library SDK Implementierung:
using Datalogics.PDFL;
public void AddHeaderFooter(string inputPath, string outputPath)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
Font font = new Font("Helvetica", FontCreateFlags.None);
for (int i = 0; i < doc.NumPages; i++)
{
using (Page page = doc.GetPage(i))
{
Content content = page.Content;
// Add header
Text header = new Text();
header.AddRun(new TextRun("Document Header",
font, 10, new Point(72, page.MediaBox.Top - 36)));
content.AddElement(header);
// Add footer with page number
Text footer = new Text();
footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
font, 10, new Point(72, 36)));
content.AddElement(footer);
page.UpdateContent();
}
}
doc.Save(SaveFlags.Full, outputPath);
}
}
finally
{
Library.Terminate();
}
}using Datalogics.PDFL;
public void AddHeaderFooter(string inputPath, string outputPath)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
Font font = new Font("Helvetica", FontCreateFlags.None);
for (int i = 0; i < doc.NumPages; i++)
{
using (Page page = doc.GetPage(i))
{
Content content = page.Content;
// Add header
Text header = new Text();
header.AddRun(new TextRun("Document Header",
font, 10, new Point(72, page.MediaBox.Top - 36)));
content.AddElement(header);
// Add footer with page number
Text footer = new Text();
footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
font, 10, new Point(72, 36)));
content.AddElement(footer);
page.UpdateContent();
}
}
doc.Save(SaveFlags.Full, outputPath);
}
}
finally
{
Library.Terminate();
}
}Imports Datalogics.PDFL
Public Sub AddHeaderFooter(inputPath As String, outputPath As String)
Library.Initialize()
Try
Using doc As New Document(inputPath)
Dim font As New Font("Helvetica", FontCreateFlags.None)
For i As Integer = 0 To doc.NumPages - 1
Using page As Page = doc.GetPage(i)
Dim content As Content = page.Content
' Add header
Dim header As New Text()
header.AddRun(New TextRun("Document Header", font, 10, New Point(72, page.MediaBox.Top - 36)))
content.AddElement(header)
' Add footer with page number
Dim footer As New Text()
footer.AddRun(New TextRun($"Page {i + 1} of {doc.NumPages}", font, 10, New Point(72, 36)))
content.AddElement(footer)
page.UpdateContent()
End Using
Next
doc.Save(SaveFlags.Full, outputPath)
End Using
Finally
Library.Terminate()
End Try
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 = "Document Header",
FontSize = 10,
FontFamily = "Helvetica"
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10,
FontFamily = "Helvetica"
};
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 = "Document Header",
FontSize = 10,
FontFamily = "Helvetica"
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10,
FontFamily = "Helvetica"
};
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 = "Document Header",
.FontSize = 10,
.FontFamily = "Helvetica"
}
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
.CenterText = "Page {page} of {total-pages}",
.FontSize = 10,
.FontFamily = "Helvetica"
}
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)
End Using
End Sub
$vbLabelText
$csharpLabel
IronPDF übernimmt die Seiteniteration automatisch und unterstützt Platzhalter-Tokens wie {page} und {total-pages}. Weitere Informationen zu fortgeschrittenen Layouts finden Sie in der Kopf- und Fußzeilen-Dokumentation.
URL zu PDF-Konvertierung
Adobe PDF Library SDK verfügt nicht über eine integrierte URL-Rendering-Funktion.IronPDF bietet native Unterstützung:
using IronPdf;
public void ConvertUrlToPdf(string url, string outputPath)
{
var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs(outputPath);
}using IronPdf;
public void ConvertUrlToPdf(string url, string outputPath)
{
var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs(outputPath);
}Imports IronPdf
Public Sub ConvertUrlToPdf(url As String, outputPath As String)
Dim renderer As New ChromePdfRenderer()
Using pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs(outputPath)
End Using
End Sub
$vbLabelText
$csharpLabel
Die vollständigen Optionen für die URL-Konvertierung finden Sie in der URL in PDF-Dokumentation.
ASP.NET Core -Integration
Das statische Initialisierungsmuster von Adobe PDF Library SDK führt zu Problemen bei der Injektion von Abhängigkeiten.IronPDF lässt sich problemlos in moderne .NET-Architekturen integrieren.
Adobe Pattern (problematisch für DI):
public class AdobePdfService
{
public byte[] Generate(string content)
{
Library.Initialize();
try
{
// Complex document construction...
return bytes;
}
finally
{
Library.Terminate();
}
}
}public class AdobePdfService
{
public byte[] Generate(string content)
{
Library.Initialize();
try
{
// Complex document construction...
return bytes;
}
finally
{
Library.Terminate();
}
}
}Public Class AdobePdfService
Public Function Generate(content As String) As Byte()
Library.Initialize()
Try
' Complex document construction...
Return bytes
Finally
Library.Terminate()
End Try
End Function
End Class
$vbLabelText
$csharpLabel
IronPDF-Muster (DI-freundlich):
public interface IPdfService
{
Task<byte[]> GeneratePdfAsync(string html);
}
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;
}
}
// Register in Program.cs (.NET 6+):
builder.Services.AddSingleton<IPdfService, IronPdfService>();public interface IPdfService
{
Task<byte[]> GeneratePdfAsync(string html);
}
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;
}
}
// Register in Program.cs (.NET 6+):
builder.Services.AddSingleton<IPdfService, IronPdfService>();Imports System.Threading.Tasks
Public Interface IPdfService
Function GeneratePdfAsync(html 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
End Class
' Register in Program.vb (.NET 6+):
builder.Services.AddSingleton(Of IPdfService, IronPdfService)()
$vbLabelText
$csharpLabel
Async-Unterstützung
Adobe PDF Library SDK unterstützt keine asynchronen Operationen.IronPDF bietet vollständige async/await-Funktionen, die für skalierbare Webanwendungen unerlässlich sind:
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
Performance-Optimierung
Vergleich der Speichernutzung
| Szenario | Adobe PDF Library SDK | IronPDF |
|---|---|---|
| Einfaches PDF | ~100 MB | ~50 MB |
| Komplexes Dokument | ~200 MB | ~80 MB |
| Stapel (100 PDFs) | Hoch (Native Memory) | ~100 MB |
Optimierungstipps
Wiederverwendung von Renderer-Instanzen:
// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"output_{i}.pdf");
}// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"output_{i}.pdf");
}' Good: Reuse renderer for batch operations
Dim renderer = 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:
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
Fehlerbehebung bei allgemeinen Migrationsproblemen
Problem: Koordinaten-basierte Positionierung funktioniert nicht
Adobe verwendet PostScript-Punktkoordinaten.IronPDF verwendet CSS-Positionierung:
// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));
// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));
// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";' Adobe: Point-based
New TextRun("Hello", font, 12, New Point(100, 700))
' IronPDF: CSS-based
Dim html As String = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>"
$vbLabelText
$csharpLabel
Problem: Unterschiede in der Seitengröße
Adobe verwendet PostScript-Punkte.IronPDF verwendet Enums oder benutzerdefinierte Dimensionen:
// Adobe: Points
Rect(0, 0, 612, 792) // Letter
// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);// Adobe: Points
Rect(0, 0, 612, 792) // Letter
// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);' Adobe: Points
Rect(0, 0, 612, 792) ' Letter
' IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)
$vbLabelText
$csharpLabel
Problem: Schriftart nicht gefunden
Adobe verlangt die manuelle Einbettung von Schriftarten.IronPDF behandelt Schriftarten automatisch:
// IronPDF: Use web fonts if needed
string html = @"
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>";// IronPDF: Use web fonts if needed
string html = @"
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>";' IronPDF: Use web fonts if needed
Dim html As String = "
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>"
$vbLabelText
$csharpLabel
Problem: SaveFlags nicht verfügbar
Adobe verwendet Speicherkennzeichen-Kombinationen.IronPDF verwendet die direkte Speicherung:
// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);
//IronPDF- full save is default
pdf.SaveAs(path);// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);
//IronPDF- full save is default
pdf.SaveAs(path);
$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
- Adobe-Lizenzkonfiguration entfernen
- CI/CD-Pipeline-Abhängigkeiten aktualisieren
- Entfernen Sie alle Adobe PDF Library DLLs aus dem Projekt.
- Dokumentieren Sie neue Muster für Ihr Entwicklungsteam
Zukunftssicherheit für Ihre PDF-Infrastruktur
Angesichts der bevorstehenden Veröffentlichung von .NET 10 und der Einführung neuer Sprachfunktionen in C# 14 stellt die Auswahl einer .NET PDF-Bibliothek mit aktiver Entwicklung die Kompatibilität mit den sich entwickelnden Laufzeitfunktionen sicher. 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 vom Adobe PDF Library SDK zuIronPDF vereinfacht Ihre PDF-Generierungs-Codebasis erheblich und reduziert gleichzeitig die Lizenzkosten deutlich. Durch den Wechsel von der Low-Level-Seitenkonstruktion zum HTML/CSS-Rendering entfallen Hunderte von Codezeilen für die Koordinatenberechnung, die Schriftverwaltung und die Lebenszyklusverwaltung. Für Teams, die moderne .NET-Anwendungen erstellen, bietetIronPDF gleichwertige Funktionen mit einer entwicklerfreundlichen API, die für zeitgemäße Entwicklungsabläufe konzipiert ist.
Kostenlos loslegen
Kostenlos loslegen
Kostenlose Live-Demo buchen
Ihr Testlizenzschlüssel wurde Ihnen per E-Mail gesendet.
