Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

Scryber.Core gegen IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 21. April 2026

Wenn .NET-Entwickler PDF-Bibliotheken zur Dokumentenerzeugung und -bearbeitung evaluieren, erscheint XFINIUM.PDF als plattformübergreifende Option mit umfassenden Low-Level-PDF-Tools. Das koordinatenbasierte Grafikprogrammiermodell unterscheidet sich jedoch erheblich von HTML-zentrierten Ansätzen. Dieser technische Vergleich zwischen XFINIUM.PDF und IronPDF soll Architekten und Entwicklern helfen, die grundlegenden Unterschiede in der Philosophie der PDF-Erzeugung, dem API-Design und der Unterstützung moderner Webinhalte zu verstehen.

XFINIUM verstehen.PDF

XFINIUM.PDF ist eine kommerzielle, plattformübergreifende PDF-Bibliothek, die vollständig in C# entwickelt wurde und sowohl für Anfänger als auch für erfahrene PDF-Entwickler gedacht ist. Die Bibliothek bietet eine breite Palette von Funktionen, darunter PDF-Generierung, Ausfüllen von Formularen, Erstellung von PDF-Portfolios, Bearbeitung von Inhalten und Konvertierung mehrseitiger TIFF-Dateien.

XFINIUM.PDF wird in zwei Editionen angeboten: die Generator Edition für die Erstellung und Bearbeitung von PDF-Dateien und die Viewer Edition, die zusätzlich Rendering- und Anzeigefunktionen bietet. Die Bibliothek bietet plattformübergreifend umfassende Werkzeuge zur PDF-Bearbeitung.

XFINIUM.PDF arbeitet jedoch nach einem grundlegend anderen Paradigma als webzentrische PDF-Bibliotheken:

Koordinatenbasierte API: Erfordert manuelle Positionierung mit Pixelkoordinaten wie DrawString("text", font, brush, 50, 100)
Keine native HTML-Unterstützung: Kann HTML/CSS nicht in PDF konvertieren, sondern ist auf Low-Level-Zeichenprimitive angewiesen
Manuelle Schriftverwaltung: Muss Schriftobjekte explizit erstellen und verwalten
Kein CSS-Styling: Keine Unterstützung für modernes Web-Styling - Farben, Schriftarten und Layouts müssen manuell bearbeitet werden
Kein JavaScript-Rendering: Nur statische Inhalte - keine dynamischen Webinhalte
Komplexes Textlayout: Manuelle Textmessung und Umbruchberechnungen erforderlich

Das grafische Programmiermodell

XFINIUM.PDF zwingt Entwickler dazu, wie Grafikprogrammierer zu denken und nicht wie Dokumentendesigner:

// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, new XPoint(50, 50));
page.Graphics.DrawString("Customer:", labelFont, brush, new XPoint(50, 80));
page.Graphics.DrawString(customer.Name, valueFont, brush, new XPoint(120, 80));
page.Graphics.DrawLine(pen, 50, 100, 550, 100);
// ... hundreds of lines for a simple document

// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, new XPoint(50, 50));
page.Graphics.DrawString("Customer:", labelFont, brush, new XPoint(50, 80));
page.Graphics.DrawString(customer.Name, valueFont, brush, new XPoint(120, 80));
page.Graphics.DrawLine(pen, 50, 100, 550, 100);
// ... hundreds of lines for a simple document

' XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, New XPoint(50, 50))
page.Graphics.DrawString("Customer:", labelFont, brush, New XPoint(50, 80))
page.Graphics.DrawString(customer.Name, valueFont, brush, New XPoint(120, 80))
page.Graphics.DrawLine(pen, 50, 100, 550, 100)
' ... hundreds of lines for a simple document

' XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, New XPoint(50, 50))
page.Graphics.DrawString("Customer:", labelFont, brush, New XPoint(50, 80))
page.Graphics.DrawString(customer.Name, valueFont, brush, New XPoint(120, 80))
page.Graphics.DrawLine(pen, 50, 100, 550, 100)
' ... hundreds of lines for a simple document

Dieser Ansatz wird zu einer Herausforderung für die Wartung, wenn sich die Anforderungen ändern, da die Position jedes Elements neu berechnet werden muss, wenn sich der Inhalt verschiebt.

IronPDF verstehen

IronPDF verfolgt bei der PDF-Erzeugung einen webzentrierten Ansatz und nutzt die Chromium-Rendering-Engine, um HTML, CSS und JavaScriptdirekt in PDF-Dokumente zu konvertieren. Anstelle des koordinatenbasierten Zeichnens ermöglicht IronPDF den Entwicklern die Verwendung vertrauter Webtechnologien für die Dokumentenerstellung.

Zu den wichtigsten Merkmalen gehören:

HTML/CSS-basiertes Design: Verwendung von Standard-Webtechnologien für das Dokumentenlayout
Chromium Rendering Engine: Volle CSS3- und JavaScript-Unterstützung durch moderne Browsertechnologie
Automatisches Layout: Keine manuellen Koordinatenberechnungen - der Inhalt fließt natürlich
Moderne Webstandards: CSS Grid, Flexbox, Webfonts und ES2024 JavaScript
URL-zu-PDF-Konvertierung: Rendering von Live-Webseiten direkt in PDF
Große Community: Umfangreiche Dokumentation, Tutorials und Support-Ressourcen

Funktionsvergleich

Die folgende Tabelle zeigt die grundlegenden Unterschiede zwischen XFINIUM.PDF und IronPDF:

Feature	XFINIUM.PDF	IronPDF
HTML zu PDF	Begrenzte HTML-Unterstützung, Schwerpunkt ist die programmatische PDF-Erstellung	Vollständige HTML-zu-PDF-Konvertierung mit umfassender Unterstützung
Gemeinschaft & Unterstützung	Kleinere Gemeinschaft, weniger Online-Ressourcen verfügbar	Große Community mit umfangreicher Dokumentation und Tutorials
Lizenz	Kommerziell mit entwicklerbasierter Lizenzierung	Kommerziell
Plattformübergreifende Unterstützung	Starke plattformübergreifende Fähigkeiten	Unterstützt auch plattformübergreifende Operationen
Spezialisierte Funktionen	Umfassende PDF-Bearbeitungswerkzeuge	Erweiterte HTML-Rendering- und PDF-Funktionen

Detaillierter Funktionsvergleich

Feature	XFINIUM.PDF	IronPDF
Inhaltserstellung
HTML zu PDF	Begrenzt (PdfHtmlTextElement)	Vollständige Chromium-Wiedergabe
URL zu PDF	Nein	Ja
CSS-Unterstützung	Nein	Vollständig CSS3
JavaScript	Nein	Vollständiger ES2024
Flexbox/Grid	Nein	Ja
Web-Schriftarten	Nein	Ja
SVG-Unterstützung	Beschränkt	Voll
Layout
Automatisches Layout	Nein	Ja
Automatische Seitenumbrüche	Nein	Ja
Manuelle Positionierung	Erforderlich	Optional (CSS-Positionierung)
Tabellen	Handzeichnung	HTML `<table>`
PDF-Betrieb
PDFs zusammenführen	Ja	Ja
PDFs teilen	Ja	Ja
Wasserzeichen	Handzeichnung	Eingebaut
Kopf-/Fußzeilen	Handbuch jede Seite	Automatisch
Entwicklung
Lernkurve	Hoch (Koordinatensystem)	Niedrig (HTML/CSS)
Code Verbosity	Sehr hoch	Niedrig
Wartung	Schwierig	Einfach
Plattformübergreifend	Ja	Ja

Unterschiede in der API-Architektur

Die architektonischen Unterschiede zwischen XFINIUM.PDF und IronPDF stellen grundlegend unterschiedliche Ansätze für die PDF-Erzeugung dar.

XFINIUM.PDF Flussdokument-Muster

XFINIUM.PDF verwendet einen mehrstufigen Prozess mit PdfFixedDocument, PdfFlowDocument, und PdfFlowContent Objekten:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();
        
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);
        
        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();
        
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);
        
        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Actions
Imports Xfinium.Pdf.FlowDocument
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim flowDocument As New PdfFlowDocument()
        
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"
        
        Dim content As New PdfFlowContent()
        content.AppendHtml(html)
        flowDocument.AddContent(content)
        
        flowDocument.RenderDocument(document)
        document.Save("output.pdf")
    End Sub
End Module

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Actions
Imports Xfinium.Pdf.FlowDocument
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim flowDocument As New PdfFlowDocument()
        
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"
        
        Dim content As New PdfFlowContent()
        content.AppendHtml(html)
        flowDocument.AddContent(content)
        
        flowDocument.RenderDocument(document)
        document.Save("output.pdf")
    End Sub
End Module

Dieses Muster erfordert das Erstellen mehrerer Dokumentobjekte, das Hinzufügen von Inhalten zu einem Flow-Container, das Rendern zu einem festen Dokument und das anschließende Speichern. Der HTML-Support durch AppendHtml ist im Vergleich zur vollständigen Browser-Rendering begrenzt.

IronPDF Stromlinienförmiges Muster

IronPDF bietet eine direkte HTML-zu-PDF-Konvertierung mit der ChromePdfRenderer Klasse:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

Die Klasse ChromePdfRenderer verwendet die Chromium-Rendering-Engine zur Verarbeitung von HTML mit vollständiger CSS3- und JavaScript-Unterstützung. Eine umfassende Anleitung zur HTML-Konvertierung finden Sie im HTML to PDF tutorial.

PDF-Zusammenführungsoperationen

Bei der Kombination mehrerer PDF-Dokumente werden erhebliche Unterschiede in der API-Komplexität zwischen den Bibliotheken deutlich.

XFINIUM.PDF Handbuch Seitenschleife

XFINIUM.PDF erfordert das Öffnen von Dateistreams, die Iteration durch Seiten und das manuelle Hinzufügen jeder Seite zu einem Ausgabedokument:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();
        
        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);
        
        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);
        
        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }
        
        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }
        
        output.Save("merged.pdf");
        
        file1.Close();
        file2.Close();
    }
}

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();
        
        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);
        
        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);
        
        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }
        
        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }
        
        output.Save("merged.pdf");
        
        file1.Close();
        file2.Close();
    }
}

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim output As New PdfFixedDocument()
        
        Dim file1 As FileStream = File.OpenRead("document1.pdf")
        Dim pdf1 As New PdfFixedDocument(file1)
        
        Dim file2 As FileStream = File.OpenRead("document2.pdf")
        Dim pdf2 As New PdfFixedDocument(file2)
        
        For i As Integer = 0 To pdf1.Pages.Count - 1
            output.Pages.Add(pdf1.Pages(i))
        Next
        
        For i As Integer = 0 To pdf2.Pages.Count - 1
            output.Pages.Add(pdf2.Pages(i))
        Next
        
        output.Save("merged.pdf")
        
        file1.Close()
        file2.Close()
    End Sub
End Class

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim output As New PdfFixedDocument()
        
        Dim file1 As FileStream = File.OpenRead("document1.pdf")
        Dim pdf1 As New PdfFixedDocument(file1)
        
        Dim file2 As FileStream = File.OpenRead("document2.pdf")
        Dim pdf2 As New PdfFixedDocument(file2)
        
        For i As Integer = 0 To pdf1.Pages.Count - 1
            output.Pages.Add(pdf1.Pages(i))
        Next
        
        For i As Integer = 0 To pdf2.Pages.Count - 1
            output.Pages.Add(pdf2.Pages(i))
        Next
        
        output.Save("merged.pdf")
        
        file1.Close()
        file2.Close()
    End Sub
End Class

Dieser Ansatz erfordert eine explizite Stream-Verwaltung, eine manuelle Iteration durch die Seiten eines jeden Dokuments und eine sorgfältige Bereinigung von Datei-Handles.

IronPDF Statische Zusammenführungsmethode

IronPDF bietet eine statische Merge Methode, die die gesamte Komplexität intern behandelt:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");
        
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");
        
        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

Die PdfDocument.Merge-Methode macht die manuelle Iteration von Seiten und die Verwaltung von Datenströmen überflüssig und reduziert die Komplexität des Codes erheblich.

Erstellen von Dokumenten mit Text und Bildern

Die Erstellung von Dokumenten mit gemischtem Inhalt zeigt den paradigmatischen Unterschied zwischen koordinatenbasierten Grafiken und HTML-basiertem Design.

XFINIUM.PDF Grafischer Ansatz

XFINIUM.PDF erfordert das Erstellen von Schriftobjekten, Pinselobjekten, das Laden von Bildern in bestimmte Bildklassen und das Zeichnen jedes Elements mit genauen Koordinaten:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();
        
        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);
        
        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);
        
        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();
        
        document.Save("output.pdf");
    }
}

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();
        
        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);
        
        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);
        
        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();
        
        document.Save("output.pdf");
    }
}

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
Imports Xfinium.Pdf.Core
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim page As PdfPage = document.Pages.Add()

        Dim font As New PdfStandardFont(PdfStandardFontFace.Helvetica, 24)
        Dim brush As New PdfBrush(PdfRgbColor.Black)

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50)

        Dim imageStream As FileStream = File.OpenRead("image.jpg")
        Dim image As New PdfJpegImage(imageStream)
        page.Graphics.DrawImage(image, 50, 100, 200, 150)
        imageStream.Close()

        document.Save("output.pdf")
    End Sub
End Module

' NuGet: Install-Package Xfinium.Pdf
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
Imports Xfinium.Pdf.Core
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim page As PdfPage = document.Pages.Add()

        Dim font As New PdfStandardFont(PdfStandardFontFace.Helvetica, 24)
        Dim brush As New PdfBrush(PdfRgbColor.Black)

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50)

        Dim imageStream As FileStream = File.OpenRead("image.jpg")
        Dim image As New PdfJpegImage(imageStream)
        page.Graphics.DrawImage(image, 50, 100, 200, 150)
        imageStream.Close()

        document.Save("output.pdf")
    End Sub
End Module

Dies erfordert das Management von PdfStandardFont, PdfBrush, PdfRgbColor, und PdfJpegImage Objekten, mit expliziter Koordinatenpositionierung für sowohl Text als auch Bilder.

IronPDF HTML-Ansatz

IronPDF verwendet Standard-HTML mit eingebetteten Bildern:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim imageBase64 As String = Convert.ToBase64String(File.ReadAllBytes("image.jpg"))
        Dim html As String = $"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim imageBase64 As String = Convert.ToBase64String(File.ReadAllBytes("image.jpg"))
        Dim html As String = $"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

HTML übernimmt das Layout automatisch - keine Koordinatenberechnungen, keine Verwaltung von Schriftobjekten, und Bilder werden auf natürliche Weise unter Verwendung von Standard <img> Tags oder Base64-Codierung eingebettet.

API-Mapping-Referenz

Teams, die eine Umstellung von XFINIUM.PDF auf IronPDF erwägen, werden dieses Mapping hilfreich finden, um Konzeptäquivalenzen zu verstehen:

XFINIUM.PDF	IronPDF
`PdfFixedDocument`	`ChromePdfRenderer`
`PdfPage`	Automatisch
`page.Graphics.DrawString()`	HTML-Textelemente
`page.Graphics.DrawImage()`	`<img>` Tag
`page.Graphics.DrawLine()`	CSS `border` oder `<hr>`
`page.Graphics.DrawRectangle()`	CSS `border` auf `<div>`
`PdfUnicodeTrueTypeFont`	CSS `font-family`
`PdfRgbColor`	CSS `color`
`PdfBrush`	CSS-Eigenschaften
`PdfPen`	CSS `border`
`PdfHtmlTextElement`	`RenderHtmlAsPdf()`
`document.Save(stream)`	`pdf.SaveAs()` oder `pdf.BinaryData`
`PdfStringAppearanceOptions`	CSS-Styling
`PdfStringLayoutOptions`	CSS-Layout

Wenn Teams den Wechsel von XFINIUM.PDF zu IronPDF erwägen

Es gibt mehrere Szenarien, die Entwicklerteams häufig dazu veranlassen,IronPDF als Alternative zu XFINIUM.PDF zu prüfen:

Moderne Anforderungen an Webinhalte

Teams, die Anwendungen erstellen, die PDFs aus webbasierten Vorlagen, Dashboards oder Berichten generieren, finden den koordinatenbasierten Ansatz von XFINIUM.PDF nur bedingt geeignet. Die Chromium-Engine von IronPDF rendert moderne CSS-Grid-, Flexbox- und JavaScript-gesteuerte Inhalte, die XFINIUM.PDF nicht unterstützen kann.

Wartung und Code-Komplexität

Die koordinatenbasierte API in XFINIUM.PDF erzeugt einen ausführlichen Code, der bei der Weiterentwicklung von Dokumentenlayouts schwer zu pflegen ist. Ein einfaches Rechnungsdokument kann in XFINIUM.PDF Hunderte von Zeilen Positionierungscode erfordern, in IronPDF dagegen nur ein paar Dutzend Zeilen HTML/CSS.

URL-zu-PDF-Funktionalität

XFINIUM.PDF kann keine Live-Webseiten in PDF umwandeln - diese Funktionalität erfordert externe HTML-Parsing-Bibliotheken.IronPDF bietet native URL-zu-PDF-Konvertierung mit vollständiger JavaScript-Ausführung und Unterstützung für dynamische Inhalte.

Vertrautheit mit Entwicklern

Für Teams mit guten Webentwicklungskenntnissen ist die Lernkurve für die koordinatenbasierte PDF-Generierung steil. HTML und CSS sind weit verbreitete Technologien, so dass der Ansatz von IronPDF auch für Entwickler ohne spezielle PDF-Kenntnisse zugänglich ist.

Automatisches Layout und Seitenumbrüche

XFINIUM.PDF erfordert eine manuelle Verfolgung der Y-Positionen und eine explizite Seitenerstellung, wenn der Inhalt die Seitengrenzen überschreitet.IronPDF verarbeitet Seitenumbrüche automatisch auf der Grundlage von CSS-Regeln und dem Inhaltsfluss.

Gemeinsame Überlegungen zur Migration

Teams, die von XFINIUM.PDF auf IronPDF umsteigen, sollten diese technischen Unterschiede berücksichtigen:

Koordinatenbasiertes bis fließendes Layout

XFINIUM.PDF erfordert genaue X,Y-Koordinaten für jedes Element.IronPDF verwendet standardmäßig das HTML-Flow-Layout. In Fällen, in denen eine absolute Positionierung erforderlich ist, bietet CSS die Möglichkeit dazu:

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Text

Font-Objekt zu CSS-Schriftfamilie

XFINIUM.PDF erstellt PdfUnicodeTrueTypeFont Objekte explizit.IronPDF verwendet die CSS-Schriftfamilie mit automatischer Schriftbehandlung:

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; }
</style>

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; }
</style>

HTML

Farbobjekte zu CSS-Farben

XFINIUM.PDF erfordert PdfRgbColor und PdfBrush Objekte.IronPDF verwendet Standard-CSS-Farben:

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }
.info { color: rgba(0, 0, 255, 0.8); }

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }
.info { color: rgba(0, 0, 255, 0.8); }

Text

Manuelle bis automatische Seitenumbrüche

Für XFINIUM.PDF müssen die Y-Position verfolgt und neue Seiten manuell erstellt werden.IronPDF bietet automatische Seitenumbrüche mit CSS-Steuerung:

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Text

Zusätzliche IronPDF-Fähigkeiten

Neben den wichtigsten Vergleichspunkten bietet IronPDF Funktionen zur Dokumentenmanipulation, die das HTML-Rendering ergänzen:

Kopf- und Fußzeilen: Automatische HTML-basierte Kopf- und Fußzeilen mit Seitennummerierung
Digitale Signaturen: Anwendung kryptografischer Signaturen für die Authentizität von Dokumenten
Wasserzeichen: Eingebaute Wasserzeichenunterstützung ohne manuelles Zeichnen
PDF/A-Konformität: Generieren von Dokumenten nach Archivierungsstandard
Formularausfüllung: Programmgesteuertes Ausfüllen von PDF-Formularfeldern
Passwortschutz: PDFs mit Benutzer- und Eigentümerpasswörtern verschlüsseln

.NET-Kompatibilität und Zukunftsfähigkeit

Beide Bibliotheken unterstützen die plattformübergreifende .NET-Entwicklung.IronPDF wird aktiv weiterentwickelt und regelmäßig aktualisiert, um die Kompatibilität mit .NET 8, .NET 9 und zukünftigen Versionen, einschließlich .NET 10, das für 2026 erwartet wird, zu gewährleisten. Der HTML/CSS-Ansatz der Bibliothek entspricht den modernen Webentwicklungspraktiken und nutzt die Fähigkeiten, über die .NET-Entwickler bereits verfügen.

Abschluss

XFINIUM.PDF und IronPDF stellen grundlegend unterschiedliche Ansätze für die PDF-Erzeugung in .NET dar. Die koordinatenbasierte Grafik-API von XFINIUM.PDF ermöglicht eine Steuerung auf niedriger Ebene, erfordert jedoch einen umfangreichen Code für das Layout des Dokuments - jedes Element muss explizit positioniert werden, Schriftobjekte und Farbmanagement sind erforderlich. Mit zunehmender Komplexität der Dokumente wird es immer schwieriger, diesen Ansatz beizubehalten.

Der HTML/CSS-basierte Ansatz von IronPDF nutzt die Chromium-Rendering-Engine, um die PDF-Erzeugung als Web-Rendering zu behandeln. Die Entwickler verwenden vertrautes HTML, CSS und JavaScript, anstatt koordinatenbasierte Grafik-APIs zu lernen. Automatisches Layout, Seitenumbrüche und die Unterstützung moderner Webstandards (CSS Grid, Flexbox, ES2024 JavaScript) reduzieren die Komplexität des Codes erheblich.

Für Teams, die Anwendungen erstellen, die webbasierte Berichte, Dashboards oder dynamische Dokumente generieren, passt der Ansatz von IronPDF natürlich zu den modernen Entwicklungspraktiken. Für Teams, die pixelgenaue Kontrolle über jedes Dokumentenelement benötigen und bereit sind, in das koordinatenbasierte Programmiermodell zu investieren, bietet die Grafik-API von XFINIUM.PDF diese Möglichkeit.

Die Wahl hängt letztlich von den Anforderungen Ihres Teams ab: Wenn Ihre PDFs aus Webinhalten stammen oder Sie HTML/CSS für das Dokumentendesign bevorzugen, bietet der Ansatz von IronPDF erhebliche Produktivitätsvorteile. Wenn Sie hochspezialisierte PDF-Inhalte mit präzisen Positionierungsanforderungen erstellen und Ihr Team über Erfahrung in der Grafikprogrammierung verfügt, kann die Low-Level-API von XFINIUM.PDF diese Anforderungen erfüllen.

Weitere Anleitungen zur Implementierung finden Sie in der IronPDF-Dokumentation und den Tutorials, die spezielle Anwendungsfälle und erweiterte Funktionen behandeln.

Hinweis:: Xfinium PDF ist eine eingetragene Marke des jeweiligen Eigentümers. Diese Seite ist nicht mit, von XFINIUM Software 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.