VIDEOS
Wie man Linien und Rechtecke auf PDFs zeichnet
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.
Warum sollten Sie einen Wechsel weg vom Adobe PDF Library SDKin Betracht ziehen?
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.
Verkaufsgetrieben, maßgeschneiderte Preisgestaltung
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.
Komplexe Native SDK-Integration
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.
Kein eingebauter HTML-Renderer
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.
Low-Level-API-Design
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.
Aufwand für die Verwaltung des Lebenszyklus von Bibliotheken
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.
Overkill für viele Projekte
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.
Adobe PDF Library SDKvs. 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 | 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 |
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 SDKzu 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 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 |
Schritt-für-Schritt-Migrationsprozess
Schritt 1: NuGet-Pakete aktualisieren
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 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 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 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
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; |
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.
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(insertAfter, src, start, count, flags) |
PdfDocument.Merge(pdfs) |
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>, 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 |
Wasserzeichen und Sicherheitsmethoden
| 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 |
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
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");
}
}
}// 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");
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeHtmlToPdf
Shared Sub Main()
Using lib As New Library()
Using doc As New Document()
' US Letter in points (8.5 x 11 inches @ 72 DPI)
Dim pageRect As New Rect(0, 0, 612, 792)
Using page As Page = doc.CreatePage(Document.BeforeFirstPage, pageRect)
Dim content As Content = page.Content
Dim font As New Font("Helvetica", FontCreateFlags.Embedded)
Dim text As New Text()
text.AddRun(New TextRun("Hello World", font, 24, New Point(72, 720)))
content.AddElement(text)
page.UpdateContent()
End Using
doc.Save(SaveFlags.Full, "output.pdf")
End Using
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. 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.
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(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");
}
}
}// 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");
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeMergePdfs
Shared Sub Main()
Using lib As New Library()
Using doc1 As New Document("document1.pdf")
Using doc2 As New Document("document2.pdf")
' InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
doc1.InsertPages(Document.LastPage, doc2, 0, Document.AllPages, PageInsertFlags.Bookmarks Or PageInsertFlags.Threads)
doc1.Save(SaveFlags.Full, "merged.pdf")
End Using
End Using
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 einzelne Merge-Methode, die mehrere Dokumente akzeptiert.
Wasserzeichen hinzufügen
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");
}
}
}// 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");
}
}
}Imports Datalogics.PDFL
Imports System
Class AdobeAddWatermark
Shared Sub Main()
Using lib As New Library()
Using doc As New Document("input.pdf")
Dim watermarkParams As New WatermarkParams()
watermarkParams.Opacity = 0.5 ' 0.0 - 1.0
watermarkParams.Rotation = 45.0
watermarkParams.Scale = -1 ' auto-fit
Dim textParams As 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")
End Using
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 von IronPDF 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 mit IronPDF 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 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.
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 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 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 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
Zusätzliche Ressourcen
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.
Hinweis:Adobe, Acrobat und Adobe PDF Library sind eingetragene Marken von Adobe Inc. APDFL wird von Datalogics, Inc. unter Lizenz von Adobe vertrieben. Diese Seite ist nicht mit Adobe Inc. oder Datalogics, Inc. 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
