Das Adobe PDF Library SDK(APDFL) wird von Datalogics unter Lizenz von Adobe vertrieben und teilt den Kernquellcode mit der Acrobat-Engine. Es ist leistungsstark, aber sein verkaufsgetriebenes Preismodell, der native Laufzeit-Footprint, der Mangel an einem eingebauten HTML-zu-PDF Renderer und das Low-Level-API-Design führen viele .NET-Teams dazu, nach Alternativen zu suchen. Dieses Handbuch bietet einen schrittweisen Migrationspfad vom Adobe PDF Library SDKzu IronPDF— einer modernen .NET-PDF-Bibliothek, die .NET Framework 4.6.2 bis .NET 9 unterstützt.
Während APDFL die Acrobat-abgeleitete PDF-Engine bietet, führen mehrere Faktoren dazu, dass Entwicklungsteams Alternativen für HTML-zu-PDF, Dokumentenmanipulation und Berichtserstellung untersuchen.
Datalogics veröffentlicht keine Listenpreise für APDFL. Laut den Preisgestaltungsseiten von Datalogics beginnen die internen Nutzungspläne bei etwa 5.999 USD/Jahr und OEM, ISV und SaaS-Bereitstellungen verhandeln pro Plattform Gebühren plus Lizenzgebühren oder Umsatzbeteiligung oben drauf. Die Gesamtkosten sind typischerweise für kleine bis mittelgroße Teams nicht erschwinglich und erfordern fast immer ein Verkaufsgespräch.
APDFL umschließt eine native C/C++-Engine, die sich mit Acrobat teilt. Das .NET-Binding (Datalogics.PDFL) erfordert plattformspezifische Laufzeit-Binaries — das Adobe.PDF.Library.LM.NET-NuGet-Paket liefert x64 Windows-, Linux- und macOS ARM-Nutzlasten — sorgfältiges Speichermanagement und einen expliziten Library-Lebenszyklus bei jedem Einstiegspunkt. Dies erhöht den Entwicklungsaufwand und kompliziert CI/CD-Pipelines.
Die dokumentierte Konversionsliste von APDFL umfasst PDF/A, PDF/X, ZUGFeRD, EPS, PS, XPS und Office-Formate, jedoch nicht HTML. Mit APDFL allein ein PDF aus einer HTML-Zeichenfolge zu erstellen bedeutet, Seiten, Schriften und Inhaltselemente von Hand zu bauen oder APDFL mit einem separaten HTML-Rendering-Engine zu paaren.
Die Erstellung von PDFs mit APDFL beinhaltet die Konstruktion von Seiten, Inhaltsströmen, Textelementen und Schriften programmatisch. Einfache Aufgaben wie das Rendern einer HTML-Zeichenfolge werden zu mehrstufigen Operationen, die Koordinatenberechnungen, Schrifteneinbettung und manuelle Verwaltung von Inhaltselementen umfassen.
Jeder Einstiegspunkt erfordert das Einbinden von Code in using (var lib = new Library()) (oder gepaarte Library.Initialize() / Library.Terminate()-Aufrufe) mit sorgfältiger Entsorgung jedes innerhalb erstellten PDF-Objekts. Versäumte Bereinigung kann zu Ressourcenlecks führen.
Für Anwendungen, die hauptsächlich HTML-zu-PDF-Konvertierung, grundlegende Dokumentenmanipulation oder Berichtserstellung benötigen, ist die vollständige Acrobat-abgeleitete Engine oft mehr als die Arbeitslast erfordert.
Das Verständnis der grundlegenden architektonischen Unterschiede zwischen diesen Bibliotheken hilft bei der Planung einer effektiven Migrationsstrategie.
| Aspekt| Adobe PDF Library SDK|IronPDF|
|--------|----------------------|---------|
| Preisgestaltung|Verkäufergeleitet; interne Nutzung ab ~5.999 USD/Jahr, OEM/SaaS-Lizenzgebühren oben drauf|Transparente pro Entwickler / pro Deployment|
| Installation|Adobe.PDF.Library.LM.NET liefert native Laufzeiten pro Plattform| Einfaches NuGet-Paket|
| Dokumentenerstellung| Aufbau von Seiten/Inhalten auf niedriger Ebene| HTML/CSS-Rendering|
|HTML zu PDF| Nicht eingebaut| ChromePdfRenderer.RenderHtmlAsPdf |
| Initialisierung|using (Library lib = new Library()) erforderlich| Automatisch|
| Koordinatensystem| PostScript-Punkte, Ursprung unten links| CSS-basiertes Layout|
| Schriftbehandlung| Manuelle Einbettung erforderlich| Automatisch|
| Speichermanagement|Manuelle Entsorgung jedes PDF-Objekts| Standard IDisposable-Muster|
| Async-Unterstützung| Nicht verfügbar| Vollständige Unterstützung von async/await|
Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt, bevor Sie mit der Migration beginnen:
Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus, um alle Verweise auf Adobe PDF Library SDKzu identifizieren:
grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .| 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 Font-Erstellung und Einbettung| 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|
Entfernen Sie das Paket Adobe PDF Library SDKund installieren Sie IronPDF:
# Remove Adobe PDF Library (.NET 6/7/8 projects)
dotnet remove package Adobe.PDF.Library.LM.NET
# .NET Framework projects use the LM.NETFramework variant
dotnet remove package Adobe.PDF.Library.LM.NETFramework
# Install IronPDF
dotnet add package IronPdfErsetzen Sie die Lizenzierung von Adobe durch den codebasierten Lizenzschlüssel von IronPDF:
// 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
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.IsLicensedFühren Sie ein globales Suchen und Ersetzen in Ihrer Lösung durch:
| Finden Sie| Ersetzen durch|
|------|--------------|
| using Datalogics.PDFL; | using IronPdf; |
APDFL stellt einen einzelnen Root-Namespace, Datalogics.PDFL, bereit. Document, Page, Content, Font, und Color sind alle Klassen innerhalb dieses Namensraums, sodass nur eine using-Direktive getauscht werden muss.
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);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)| 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|
| 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(insertAfter, src, start, count, flags) | PdfDocument.Merge(pdfs) |
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>, usw.|
| 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|
| Adobe-Methode| IronPDF-Methode|
|--------------|----------------|
| doc.Watermark(textParams, wmParams) | pdf.ApplyWatermark(html) |
|WatermarkParams.Opacity (0,0-1,0)|opacity-Parameter (0-100) oder CSS opacity|
| new EncryptionHandler(user, owner, perms) | pdf.SecuritySettings |
| PermissionFlags.PrintDoc | AllowUserPrinting |
| Adobe-Methode| IronPDF-Methode|
|--------------|----------------|
| new WordFinder(doc, config) | pdf.ExtractAllText() |
| wordFinder.GetWordList() | pdf.Pages[i].Text |
| Komplexe Wort-/Zeichenwiederholung| Einzelner Methodenaufruf|
APDFL hat keinen eingebauten HTML-Renderer. Das am nächsten liegende ist das manuelle Erstellen von Seiten und Inhaltselementen, um das Layout eines HTML-Dokuments zu imitieren — oder das Koppeln von APDFL mit einer separaten HTML-zu-PDF-Engine.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK(Datalogics APDFL)
// NuGet: Adobe.PDF.Library.LM.NET — namespace Datalogics.PDFL
using Datalogics.PDFL;
using System;
class AdobeHtmlToPdf
{
static void Main()
{
using (Library lib = new Library())
using (Document doc = new Document())
{
// US Letter in points (8.5 x 11 inches @ 72 DPI)
Rect pageRect = new Rect(0, 0, 612, 792);
using (Page page = doc.CreatePage(Document.BeforeFirstPage, pageRect))
{
Content content = page.Content;
Font font = new Font("Helvetica", FontCreateFlags.Embedded);
Text text = new Text();
text.AddRun(new TextRun("Hello World", font, 24, new Point(72, 720)));
content.AddElement(text);
page.UpdateContent();
}
doc.Save(SaveFlags.Full, "output.pdf");
}
}
}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
Imports IronPdf
Imports System
Class IronPdfHtmlToPdf
Shared Sub Main()
Dim renderer As 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 ClassIronPDF macht den Library Lifecycle Wrapper, die Konvertierungsparameterobjekte und die explizite Entsorgung überflüssig. Das ChromePdfRenderer verwendet eine auf Chromium basierende Engine für pixelgenaues CSS und JavaScript-Unterstützung. Für fortgeschrittene Szenarien siehe die HTML zu PDF Dokumentation.
Die PDF-Zusammenführung zeigt den Unterschied in der API-Komplexität deutlich auf.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;
class AdobeMergePdfs
{
static void Main()
{
using (Library lib = new Library())
using (Document doc1 = new Document("document1.pdf"))
using (Document doc2 = new Document("document2.pdf"))
{
// InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
doc1.InsertPages(
Document.LastPage,
doc2,
0,
Document.AllPages,
PageInsertFlags.Bookmarks | PageInsertFlags.Threads);
doc1.Save(SaveFlags.Full, "merged.pdf");
}
}
}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
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 ClassDer Ansatz von Adobe erfordert eine seitenweise Iteration mit Einfügeparametern.IronPDF bietet eine einzelne Merge-Methode, die mehrere Dokumente akzeptiert.
Das Wasserzeichen veranschaulicht, wie IronPDF HTML/CSS für die flexible Gestaltung nutzt.
Adobe PDF Library SDK Implementierung:
// Adobe PDF Library SDK(Datalogics APDFL)
using Datalogics.PDFL;
using System;
class AdobeAddWatermark
{
static void Main()
{
using (Library lib = new Library())
using (Document doc = new Document("input.pdf"))
{
WatermarkParams watermarkParams = new WatermarkParams();
watermarkParams.Opacity = 0.5; // 0.0 - 1.0
watermarkParams.Rotation = 45.0;
watermarkParams.Scale = -1; // auto-fit
WatermarkTextParams textParams = new WatermarkTextParams();
textParams.Text = "CONFIDENTIAL";
textParams.Color = new Color(0.8, 0.8, 0.8);
textParams.TextAlign = HorizontalAlignment.Center;
// Apply via Document.Watermark(textParams, wmParams)
doc.Watermark(textParams, watermarkParams);
doc.Save(SaveFlags.Full, "watermarked.pdf");
}
}
}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
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 ClassDas HTML-basierte Wasserzeichen von IronPDF bietet vollständige Designkontrolle durch CSS-Styling und macht separate Parameterobjekte überflüssig.
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();
}
}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 SubIronPDF-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);
}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 SubIronPDF verwendet stark typisierte Eigenschaften anstelle von bitweisen Berechtigungsflags und Verschlüsselungshandler-Objekten.
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;
}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 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 Wort-für-Wort-Iteration von Adobe wird mit IronPDF zu einem einzigen Methodenaufruf.
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();
}
}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 SubIronPDF-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);
}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 SubIronPDF behandelt die Seiteniteration automatisch und unterstützt Platzhaltertokens wie {page} und {total-pages}. Weitere Informationen zu fortgeschrittenen Layouts finden Sie in der Kopf- und Fußzeilen-Dokumentation.
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);
}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 SubDie vollständigen Optionen für die URL-Konvertierung finden Sie in der URL in PDF-Dokumentation.
Das statische Initialisierungsmuster von Adobe PDF Library SDKfü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
{
// Komplexes Dokumentconstruction...
return bytes;
}
finally
{
Library.Terminate();
}
}
}Public Class AdobePdfService
Public Function Generate(content As String) As Byte()
Library.Initialize()
Try
' Komplexes Dokumentconstruction...
Return bytes
Finally
Library.Terminate()
End Try
End Function
End ClassIronPDF-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>();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)()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");
}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| 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|
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
Dim renderer = New ChromePdfRenderer()
For Each html In htmlList
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"output_{i}.pdf")
End Using
NextVerwendung 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");
}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 ClassAdobe 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
Dim html As String = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>"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 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
Dim html As String = "
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>"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);netÜberprüfen Sie nach Abschluss der Codemigration Folgendes:
IronPdf.License.IsLicensed)Die Migration von APDFL zu IronPDF kann die typische .NET-PDF-Generierungscodebasis vereinfachen, insbesondere für Teams, deren Hauptbedarf HTML-zu-PDF oder Dokumentenmanipulation anstelle der vollständigen Acrobat-abgeleiteten Funktionsoberfläche ist. Der Wechsel von der niedrigen Seitenkonstruktion zur HTML/CSS-Darstellung entfernt die meisten Koordinatenberechnungen, Schriftverwaltungen und Library-Lebenszyklusbehandlung des Codes und IronPDFs transparente Entwicklerlizenzierung ist in der Regel einfacher zu budgetieren als APDFLs verkaufsgeführtes, OEM/SaaS-Royalty-Modell.
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
