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

PdfPig gegen IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 28. Juni 2026

Wenn .NET-Entwickler Bibliotheken zur PDF-Erzeugung und -Bearbeitung evaluieren, stellen Spire.PDF und IronPDF grundlegend unterschiedliche Ansätze dar, die sich erheblich auf die Qualität und die Benutzerfreundlichkeit von Dokumenten auswirken. Spire.PDF ist eine umfassende PDF-Bibliothek innerhalb der Office-Suite E-iceblue, während IronPDF eine moderne, Chromium-basierte HTML-to-PDF-Engine bietet. In diesem technischen Vergleich werden beide Bibliotheken in den Dimensionen untersucht, die für professionelle Entwickler und Architekten bei der Entscheidung über die PDF-Erzeugung for .NET-Anwendungen im Jahr 2025 und darüber hinaus am wichtigsten sind.

Spire.PDF verstehen

Spire.PDF ist eine kommerzielle PDF-Bibliothek für .NET-Entwickler, die als Teil der umfassenden Office-Suite E-iceblue bekannt ist. Ihre Integrationsmöglichkeiten sind auf andere Komponenten der Suite abgestimmt und bieten eine einheitliche Entwicklungserfahrung für Unternehmen, die neben Word-, Excel- und PowerPoint-Verarbeitung auch umfangreiche PDF-Bearbeitung benötigen.

Spire.PDF bietet einen vielseitigen Ansatz für den Umgang mit PDF-Dateien, mit dem PDF-Dateien erstellt, gelesen, geschrieben und bearbeitet werden können. Diese Vielseitigkeit ist der Grund dafür, dass die Übersetzung in Szenarien eingesetzt werden kann, die eine Kompatibilität mit älteren Versionen und eine werkzeugübergreifende Konsistenz innerhalb des E-iceblue-Ökosystems erfordern.

Kritische Einschränkung: Spire.PDF hat ein erhebliches architektonisches Problem—bei der Konvertierung von HTML zu PDF mit der LoadFromHTML()-Methode werden Texte oft als Bitmap-Bilder dargestellt anstelle von echtem Text. So entstehen PDFs, in denen der Text nicht ausgewählt, durchsucht oder kopiert werden kann.

IronPDF verstehen

IronPDF bietet eine kommerziell unterstützte Bibliothek zur PDF-Erzeugung, die eine moderne Chromium-basierte Rendering-Engine verwendet. Die Bibliothek wandelt HTML, CSS und JavaScript in PDF-Dokumente mit echtem Text-Rendering um und gewährleistet, dass der gesamte Text auswählbar, durchsuchbar und zugänglich bleibt.

Im Gegensatz zum bildbasierten Ansatz von Spire.PDF behält IronPDF den Text als echte Textzeichen in der resultierenden PDF-Datei bei und unterstützt alle CSS3-Funktionen wie Flexbox, CSS Grid und CSS Variables.

Das Text-als-Bilder-Problem

Der wichtigste Unterschied zwischen Spire.PDF und IronPDF liegt in der Art und Weise, wie der Text in den PDF-Dokumenten dargestellt wird. Dieser grundlegende architektonische Unterschied wirkt sich in mehrfacher Hinsicht auf die Nutzbarkeit der Dokumente aus.

Spire.PDF Bildbasiertes Rendering

Wenn Spire.PDF HTML in PDF konvertiert, wird der Text oft als Bitmap-Bild gerendert:

// [X] Spire.PDF - Creates image-based PDF
PdfDocument pdf = new PdfDocument();
pdf.LoadFromHTML("<h1>Important Contract</h1>", false, true, true);
pdf.SaveToFile("contract.pdf");

// Problems with resulting PDF:
// - Text CANNOT be selected
// - Text CANNOT be searched
// - Text CANNOT be copied
// - Screen readers CANNOT read it (accessibility violation)
// - File size is MUCH larger
// - Zooming causes pixelation

// [X] Spire.PDF - Creates image-based PDF
PdfDocument pdf = new PdfDocument();
pdf.LoadFromHTML("<h1>Important Contract</h1>", false, true, true);
pdf.SaveToFile("contract.pdf");

// Problems with resulting PDF:
// - Text CANNOT be selected
// - Text CANNOT be searched
// - Text CANNOT be copied
// - Screen readers CANNOT read it (accessibility violation)
// - File size is MUCH larger
// - Zooming causes pixelation

Imports Spire.Pdf

' [X] Spire.PDF - Creates image-based PDF
Dim pdf As New PdfDocument()
pdf.LoadFromHTML("<h1>Important Contract</h1>", False, True, True)
pdf.SaveToFile("contract.pdf")

' Problems with resulting PDF:
' - Text CANNOT be selected
' - Text CANNOT be searched
' - Text CANNOT be copied
' - Screen readers CANNOT read it (accessibility violation)
' - File size is MUCH larger
' - Zooming causes pixelation

Imports Spire.Pdf

' [X] Spire.PDF - Creates image-based PDF
Dim pdf As New PdfDocument()
pdf.LoadFromHTML("<h1>Important Contract</h1>", False, True, True)
pdf.SaveToFile("contract.pdf")

' Problems with resulting PDF:
' - Text CANNOT be selected
' - Text CANNOT be searched
' - Text CANNOT be copied
' - Screen readers CANNOT read it (accessibility violation)
' - File size is MUCH larger
' - Zooming causes pixelation

IronPDF Echte Textrendering

IronPDF behält den Text als tatsächliche Textzeichen bei:

using IronPdf;

//IronPDF- Creates real text PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Important Contract</h1>");
pdf.SaveAs("contract.pdf");

// Result:
// Text is fully selectable
// Text is searchable with Ctrl+F
// Text can be copied to clipboard
// Screen readers work perfectly
// File size is compact
// Zooming is crystal clear

using IronPdf;

//IronPDF- Creates real text PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Important Contract</h1>");
pdf.SaveAs("contract.pdf");

// Result:
// Text is fully selectable
// Text is searchable with Ctrl+F
// Text can be copied to clipboard
// Screen readers work perfectly
// File size is compact
// Zooming is crystal clear

Imports IronPdf

' IronPDF- Creates real text PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Important Contract</h1>")
pdf.SaveAs("contract.pdf")

' Result:
' Text is fully selectable
' Text is searchable with Ctrl+F
' Text can be copied to clipboard
' Screen readers work perfectly
' File size is compact
' Zooming is crystal clear

Imports IronPdf

' IronPDF- Creates real text PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Important Contract</h1>")
pdf.SaveAs("contract.pdf")

' Result:
' Text is fully selectable
' Text is searchable with Ctrl+F
' Text can be copied to clipboard
' Screen readers work perfectly
' File size is compact
' Zooming is crystal clear

Auswirkungen auf die Benutzerfreundlichkeit des Dokuments

Fähigkeit	Spire.PDF (Bildbasiert)	IronPDF(True Text)
Textauswahl	Nein Nicht möglich	Ja Volle Auswahl
Textsuche (Strg+F)	Nein "Keine Übereinstimmungen gefunden"	Ja Funktioniert perfekt
Kopieren/Einfügen	Nein Nichts wird kopiert	Ja Funktioniert perfekt
Bildschirmleser	Nein Inhalt kann nicht gelesen werden	Ja Volle Zugänglichkeit
Dateigröße	Groß (Bilder)	Kompakt (Text)
Zoom Qualität	Verpixelt	Kristallklar

Das Internet Explorer Rendering Problem

Spire.PDF verlässt sich in vielen Szenarien auf Internet Explorer/Edge Legacy für das HTML-Rendering, was zu Kompatibilitätsproblemen mit modernen Webstandards führt.

Spire.PDF Rendering-EngineEinschränkungen

<!-- This HTML renders incorrectly in Spire.PDF -->
<div style="display: flex; justify-content: space-between; gap: 20px;">
    <div style="flex: 1;">Column 1</div>
    <div style="flex: 1;">Column 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px;">
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>

<!-- CSS Variables don't work -->
<style>
:root { --primary-color: #007bff; }
h1 { color: var(--primary-color); }
</style>

<!-- This HTML renders incorrectly in Spire.PDF -->
<div style="display: flex; justify-content: space-between; gap: 20px;">
    <div style="flex: 1;">Column 1</div>
    <div style="flex: 1;">Column 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px;">
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>

<!-- CSS Variables don't work -->
<style>
:root { --primary-color: #007bff; }
h1 { color: var(--primary-color); }
</style>

HTML

IronPDF Moderne Chromium Engine

IronPDF verwendet die moderne Chromium-Rendering-Engine und unterstützt alle aktuellen CSS-Funktionen:

using IronPdf;

//IronPDF- Uses modern Chromium rendering
var renderer = new ChromePdfRenderer();

var html = @"
<style>
    :root { --primary: #007bff; }
    .container { display: flex; gap: 20px; }
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); }
</style>
<div class='container'>
    <div style='flex: 1; color: var(--primary)'>Column 1</div>
    <div style='flex: 1'>Column 2</div>
</div>
<div class='grid'>
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
// All modern CSS features render correctly!

using IronPdf;

//IronPDF- Uses modern Chromium rendering
var renderer = new ChromePdfRenderer();

var html = @"
<style>
    :root { --primary: #007bff; }
    .container { display: flex; gap: 20px; }
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); }
</style>
<div class='container'>
    <div style='flex: 1; color: var(--primary)'>Column 1</div>
    <div style='flex: 1'>Column 2</div>
</div>
<div class='grid'>
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
// All modern CSS features render correctly!

Imports IronPdf

' IronPDF- Uses modern Chromium rendering
Dim renderer As New ChromePdfRenderer()

Dim html As String = "
<style>
    :root { --primary: #007bff; }
    .container { display: flex; gap: 20px; }
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); }
</style>
<div class='container'>
    <div style='flex: 1; color: var(--primary)'>Column 1</div>
    <div style='flex: 1'>Column 2</div>
</div>
<div class='grid'>
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
' All modern CSS features render correctly!

Imports IronPdf

' IronPDF- Uses modern Chromium rendering
Dim renderer As New ChromePdfRenderer()

Dim html As String = "
<style>
    :root { --primary: #007bff; }
    .container { display: flex; gap: 20px; }
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); }
</style>
<div class='container'>
    <div style='flex: 1; color: var(--primary)'>Column 1</div>
    <div style='flex: 1'>Column 2</div>
</div>
<div class='grid'>
    <div>Item 1</div>
    <div>Item 2</div>
    <div>Item 3</div>
</div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
' All modern CSS features render correctly!

Übersicht über den Funktionsvergleich

Feature	Spire.PDF	IronPDF
HTML-Rendering	IE/Edge-basiert (veraltet)	Chromium (modern)
Textausgabe	Bilder (nicht auswählbar)	Echter Text (auswählbar)
CSS3-Unterstützung	Beschränkt	Voll
Flexbox/Grid	Nicht unterstützt	Unterstützt
JavaScript	Beschränkt	Vollständig ES6+
Schrifteinbettung	Problematisch	Zuverlässig
PDF Barrierefreiheit	Schlecht (bildbasiert)	Ausgezeichnet
Modernes .NET	.NET 6+ teilweise	Vollständig .NET 6-9
API-Entwurf	Komplex	Einfach und intuitiv
Bereitstellungsumfang	Groß	Mäßig

HTML zu PDF Konvertierung

Der zentrale HTML-zu-PDF-Workflow demonstriert die grundlegenden API- und Ausgabeunterschiede zwischen den Bibliotheken.

Spire.PDF HTML-Konvertierung

Spire.PDF verwendet die LoadFromHTML()-Methode mit mehreren booleschen Parametern:

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfHtmlLayoutFormat htmlLayoutFormat = new PdfHtmlLayoutFormat();
        
        string htmlString = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        pdf.LoadFromHTML(htmlString, false, true, true);
        pdf.SaveToFile("output.pdf");
        pdf.Close();
    }
}

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfHtmlLayoutFormat htmlLayoutFormat = new PdfHtmlLayoutFormat();
        
        string htmlString = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";
        
        pdf.LoadFromHTML(htmlString, false, true, true);
        pdf.SaveToFile("output.pdf");
        pdf.Close();
    }
}

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System

Module Program
    Sub Main()
        Dim pdf As New PdfDocument()
        Dim htmlLayoutFormat As New PdfHtmlLayoutFormat()

        Dim htmlString As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        pdf.LoadFromHTML(htmlString, False, True, True)
        pdf.SaveToFile("output.pdf")
        pdf.Close()
    End Sub
End Module

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System

Module Program
    Sub Main()
        Dim pdf As New PdfDocument()
        Dim htmlLayoutFormat As New PdfHtmlLayoutFormat()

        Dim htmlString As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        pdf.LoadFromHTML(htmlString, False, True, True)
        pdf.SaveToFile("output.pdf")
        pdf.Close()
    End Sub
End Module

Dieser Ansatz erfordert:

Erstellen einer PdfDocument-Instanz
Optionale Konfiguration von PdfHtmlLayoutFormat
Aufrufen von LoadFromHTML() mit mehreren booleschen Parametern
Expliziter Close()-Aufruf nach dem Speichern
Kritisch: Text kann als Bilder wiedergegeben werden

IronPDF HTML-Konvertierung

IronPDF bietet die ChromePdfRenderer mit einer sauberen API:

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

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

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

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

Die Methode RenderHtmlAsPdf verwendet die Chromium-Rendering-Engine und erzeugt eine echte Textausgabe. Kein Close()-Aufruf erforderlich—IronPDF verwendet das standardmäßige Dispose-Muster.

PDF-Zusammenführung

Bei der Zusammenführung mehrerer PDF-Dokumente werden unterschiedliche API-Muster zwischen den Bibliotheken deutlich.

Spire.PDF PDF-Zusammenführung

Spire.PDF führt Dokumente mit der InsertPageRange()-Methode zusammen:

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf1 = new PdfDocument();
        pdf1.LoadFromFile("document1.pdf");
        
        PdfDocument pdf2 = new PdfDocument();
        pdf2.LoadFromFile("document2.pdf");
        
        pdf1.InsertPageRange(pdf2, 0, pdf2.Pages.Count - 1);
        
        pdf1.SaveToFile("merged.pdf");
        pdf1.Close();
        pdf2.Close();
    }
}

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf1 = new PdfDocument();
        pdf1.LoadFromFile("document1.pdf");
        
        PdfDocument pdf2 = new PdfDocument();
        pdf2.LoadFromFile("document2.pdf");
        
        pdf1.InsertPageRange(pdf2, 0, pdf2.Pages.Count - 1);
        
        pdf1.SaveToFile("merged.pdf");
        pdf1.Close();
        pdf2.Close();
    }
}

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports System

Module Program
    Sub Main()
        Dim pdf1 As New PdfDocument()
        pdf1.LoadFromFile("document1.pdf")
        
        Dim pdf2 As New PdfDocument()
        pdf2.LoadFromFile("document2.pdf")
        
        pdf1.InsertPageRange(pdf2, 0, pdf2.Pages.Count - 1)
        
        pdf1.SaveToFile("merged.pdf")
        pdf1.Close()
        pdf2.Close()
    End Sub
End Module

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports System

Module Program
    Sub Main()
        Dim pdf1 As New PdfDocument()
        pdf1.LoadFromFile("document1.pdf")
        
        Dim pdf2 As New PdfDocument()
        pdf2.LoadFromFile("document2.pdf")
        
        pdf1.InsertPageRange(pdf2, 0, pdf2.Pages.Count - 1)
        
        pdf1.SaveToFile("merged.pdf")
        pdf1.Close()
        pdf2.Close()
    End Sub
End Module

Dieser Ansatz erfordert:

Jedes Dokument einzeln laden
Verwendung der Seitenbereichsberechnung (pdf2.Pages.Count - 1)
Einfügen in das erste Dokument (Ändern des Dokuments)
Beide Dokumente ausdrücklich schließen

IronPDF PDF-Zusammenführung

IronPDF stellt eine statische Merge()-Methode bereit:

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

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;

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

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")
        
        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        
        merged.SaveAs("merged.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")
        
        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        
        merged.SaveAs("merged.pdf")
    End Sub
End Module

Die Methode PdfDocument.Merge() erstellt ein neues zusammengeführtes Dokument, ohne die Originale zu verändern. Keine expliziten Close()-Aufrufe erforderlich.

Text in PDFs einfügen

Das Hinzufügen von Text zu bestehenden Dokumenten demonstriert verschiedene Text-Rendering-Philosophien.

Spire.PDF Text hinzufügen

Spire.PDF verwendet einen leinwandbasierten Zeichenansatz:

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();
        
        PdfFont font = new PdfFont(PdfFontFamily.Helvetica, 20);
        PdfBrush brush = new PdfSolidBrush(Color.Black);
        
        page.Canvas.DrawString("Hello from Spire.PDF!", font, brush, new PointF(50, 50));
        
        pdf.SaveToFile("output.pdf");
        pdf.Close();
    }
}

// NuGet: Install-Package Spire.PDF
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;
using System;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();
        
        PdfFont font = new PdfFont(PdfFontFamily.Helvetica, 20);
        PdfBrush brush = new PdfSolidBrush(Color.Black);
        
        page.Canvas.DrawString("Hello from Spire.PDF!", font, brush, new PointF(50, 50));
        
        pdf.SaveToFile("output.pdf");
        pdf.Close();
    }
}

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System.Drawing

Module Program
    Sub Main()
        Dim pdf As New PdfDocument()
        Dim page As PdfPageBase = pdf.Pages.Add()
        
        Dim font As New PdfFont(PdfFontFamily.Helvetica, 20)
        Dim brush As PdfBrush = New PdfSolidBrush(Color.Black)
        
        page.Canvas.DrawString("Hello from Spire.PDF!", font, brush, New PointF(50, 50))
        
        pdf.SaveToFile("output.pdf")
        pdf.Close()
    End Sub
End Module

' NuGet: Install-Package Spire.PDF
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System.Drawing

Module Program
    Sub Main()
        Dim pdf As New PdfDocument()
        Dim page As PdfPageBase = pdf.Pages.Add()
        
        Dim font As New PdfFont(PdfFontFamily.Helvetica, 20)
        Dim brush As PdfBrush = New PdfSolidBrush(Color.Black)
        
        page.Canvas.DrawString("Hello from Spire.PDF!", font, brush, New PointF(50, 50))
        
        pdf.SaveToFile("output.pdf")
        pdf.Close()
    End Sub
End Module

Dieser Ansatz erfordert:

Erstellen von Schrift- und Pinselobjekten
Verwendung von Canvas-Zeichenmethoden
Koordinatenbasierte Positionierung mit PointF
Explizite Ressourcenverwaltung

IronPDF Textzusatz

IronPDF verwendet einen Stamper-basierten Ansatz:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body></body></html>");
        
        var textStamper = new TextStamper()
        {
            Text = "Hello from IronPDF!",
            FontSize = 20,
            VerticalOffset = 50,
            HorizontalOffset = 50
        };
        
        pdf.ApplyStamp(textStamper);
        pdf.SaveAs("output.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body></body></html>");
        
        var textStamper = new TextStamper()
        {
            Text = "Hello from IronPDF!",
            FontSize = 20,
            VerticalOffset = 50,
            HorizontalOffset = 50
        };
        
        pdf.ApplyStamp(textStamper);
        pdf.SaveAs("output.pdf");
    }
}

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

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body></body></html>")
        
        Dim textStamper As New TextStamper() With {
            .Text = "Hello from IronPDF!",
            .FontSize = 20,
            .VerticalOffset = 50,
            .HorizontalOffset = 50
        }
        
        pdf.ApplyStamp(textStamper)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

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

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body></body></html>")
        
        Dim textStamper As New TextStamper() With {
            .Text = "Hello from IronPDF!",
            .FontSize = 20,
            .VerticalOffset = 50,
            .HorizontalOffset = 50
        }
        
        pdf.ApplyStamp(textStamper)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

Die Klasse TextStamper bietet einen deklarativen Ansatz mit benannten Eigenschaften, so dass die Erstellung separater Schrift- und Pinselobjekte nicht mehr erforderlich ist.

API-Mapping-Referenz

Teams, die eine Migration von Spire.PDF auf IronPDF prüfen, können sich auf diese Zuordnung gleichwertiger Operationen beziehen:

Spire.PDF	IronPDF
`PdfDocument`	`PdfDocument`
`pdf.LoadFromHTML()`	`renderer.RenderHtmlAsPdf()`
`pdf.LoadFromFile()`	`PdfDocument.FromFile()`
`pdf.SaveToFile()`	`pdf.SaveAs()`
`pdf.Close()`	Nicht erforderlich
`pdf.InsertPageRange()`	`PdfDocument.Merge()`
`PdfFont` + `PdfBrush`	`TextStamper`
`page.Canvas.DrawString()`	`pdf.ApplyStamp()`
`PdfHtmlLayoutFormat`	`RenderingOptions`

Kritische technische Fragen

Bekannte Probleme mit Spire.PDF

Problem	Auswirkungen	IronPDF Lösung
Text als Bilder gerendert	PDFs nicht durchsuchbar, nicht zugänglich, Text kann nicht kopiert werden	Echte Textwiedergabe
Internet Explorer-Abhängigkeit	Veraltetes Rendering, Sicherheitsrisiken	Moderne Chromium-Engine
Fehler bei der Schrifteinbettung	Dokumente sehen auf anderen Systemen falsch aus	Zuverlässige Handhabung von Schriftarten
Großer Einsatzbereich	Hoher Speicherverbrauch, langsames Starten	Effiziente Bereitstellung
Beschränkte CSS-Unterstützung	Moderne Layouts werden nicht korrekt wiedergegeben	Vollständige CSS3-Unterstützung

Einhaltung der Barrierefreiheit

Bildbasierte PDFs, die mit der LoadFromHTML()-Methode von Spire.PDF erstellt wurden, führen zu Problemen mit der Barrierefreiheit:

WCAG 2.1-Konformität - Erfüllt nicht die Anforderungen an die Barrierefreiheit von Texten
Konformität mit Abschnitt 508 - Entspricht nicht den Zugänglichkeitsstandards der US-Regierung
ADA-Anforderungen - Erfüllt die Anforderungen des Americans with Disabilities Act
Bildschirmleser-Kompatibilität - Inhalt kann nicht gelesen werden

Das True-Text-Rendering von IronPDF gewährleistet die vollständige Einhaltung der Barrierefreiheit, so dass Bildschirmlesegeräte den gesamten Dokumentinhalt lesen können.

Wenn Teams die Migration von Spire.PDF in Betracht ziehen

Mehrere Faktoren veranlassen Entwicklungsteams, Alternativen zu Spire.PDF zu prüfen:

Anforderungen an die Textauswahl werden kritisch, wenn Benutzer Inhalte kopieren oder innerhalb von Dokumenten suchen müssen oder wenn Dokumentenmanagementsysteme PDF-Inhalte indizieren müssen. Das bildbasierte Rendering von Spire.PDF blockiert all diese Fähigkeiten.

Zugänglichkeitskonformität betrifft Organisationen, die den WCAG-, Section 508- oder ADA-Anforderungen unterliegen. Bildbasierte PDF-Dokumente werden bei Zugänglichkeitsprüfungen nicht berücksichtigt und können zu rechtlichen Problemen führen.

Moderne CSS-Layouts werden nicht korrekt wiedergegeben, wenn Designs Flexbox, CSS Grid oder CSS Variables verwenden. Das Internet Explorer-basierte Rendering von Spire.PDF kann diese modernen Webstandards nicht verarbeiten.

Probleme bei der Schrifteinbettung führen dazu, dass die Dokumente auf verschiedenen Systemen nicht korrekt angezeigt werden. Benutzer berichten, dass Spire.PDF Probleme mit der korrekten Einbettung von Schriften hat, was die Dokumententreue beeinträchtigt.

Großer Aufwand für die Bereitstellung wirkt sich auf ressourcenbeschränkte Umgebungen aus. Der operative Fußabdruck von Spire.PDF wirkt sich auf die Nutzung des Systemspeichers und die damit verbundenen Kosten aus.

Stärken und Gegensätze

Spire.PDF Stärken

Teil der umfassenden E-iceblue Office Suite
Integration mit anderen Komponenten der Suite (Word, Excel, PowerPoint)
Geeignet für Legacy-Anwendungen, die werkzeugübergreifende Konsistenz erfordern
Vielseitige PDF-Bearbeitungsfunktionen
Freemium-Lizenzierungsoption verfügbar

Einschränkungen von Spire.PDF

Als Bilder gerenderter Text (nicht auswählbar, durchsuchbar oder zugänglich)
Internet Explorer-abhängige Rendering-Engine
Bekannte Probleme bei der Schrifteinbettung
Großer Einsatzbereich
Begrenzte Unterstützung für modernes CSS (keine Flexbox, Grid, CSS-Variablen)
Komplexe API, die eine explizite Ressourcenverwaltung erfordert

IronPDF Stärken

Echte Textwiedergabe (auswählbar, durchsuchbar, zugänglich)
Moderne Chromium-basierte Engine mit vollständiger CSS3-Unterstützung
Zuverlässige Handhabung von Schriftarten
Moderater Aufwand für die Bereitstellung
Umfassende Dokumentation und professioneller Support
Einfache API ohne explizite Close()-Anforderungen
Vollständige Unterstützung von Flexbox, CSS-Grid und CSS-Variablen
Funktionen zur PDF-Bearbeitung (Zusammenführen, Teilen, Stempeln)

IronPDF Überlegungen

Kommerzielles Lizenzierungsmodell
Verschiedene API-Muster aus der E-iceblue-Suite

Vergleichstabelle

Feature	Spire.PDF	IronPDF
HTML-zu-PDF-Rendering	Als Bilder gerenderter Text	Echte Textwiedergabe (auswählbar und durchsuchbar)
Rendering-Engine	Internet Explorer abhängig	Chromium-basiert, konform mit modernen Webstandards
Handhabung von Schriftarten	Bekannte Probleme mit der Schrifteinbettung	Zuverlässige und robuste Handhabung von Schriftarten
Anwendungsfall	Ältere Anwendungen, Office-Suite	Moderne Anwendungen, präzise Wiedergabe von Dokumenten
Lizenzierung	Freemium/Kommerziell	Kommerziell
Umfang der Bereitstellung	Groß	Mäßig

Abschluss

Spire.PDF und IronPDF dienen unterschiedlichen organisatorischen Kontexten und technischen Anforderungen. Spire.PDF bietet einen Mehrwert für Unternehmen, die bereits stark in die E-iceblue Office Suite investiert haben und Kompatibilität mit älteren Versionen und werkzeugübergreifende Konsistenz benötigen. Die Integrationsfunktionen sind auf andere Komponenten der Suite abgestimmt, um eine einheitliche Entwicklungserfahrung zu gewährleisten.

Für Anwendungen, die Textauswahl, Durchsuchbarkeit, Barrierefreiheit oder modernes CSS-Rendering erfordern, bietet IronPDF wichtige Funktionen, die Spire.PDF nicht bieten kann. Die Chromium-basierte Rendering-Engine sorgt für eine echte Textausgabe mit voller CSS3-Unterstützung, wodurch die grundlegenden Einschränkungen der bildbasierten PDF-Generierung beseitigt werden.

Bei der Evaluierung der Migration von Spire.PDF zu IronPDF sollten die Teams ihre spezifischen Anforderungen in Bezug auf Textzugänglichkeit, Durchsuchbarkeit der Dokumente, moderne CSS-Unterstützung und Einhaltung der Barrierefreiheit berücksichtigen. Für Teams, die .NET 10 und C# 14 im Jahr 2026 mit Anforderungen an die Barrierefreiheit anstreben, bietet die Architektur von IronPDF zur Wiedergabe von echtem Text eine geeignetere Grundlage als der bildbasierte Ansatz von Spire.PDF.

Eine Anleitung zur Implementierung finden Sie im IronPDF HTML-zu-PDF-Tutorial und in der Dokumentation, die PDF-Erzeugungsmuster für moderne .NET-Anwendungen abdeckt.

Hinweis:: Spire ist ein eingetragenes Warenzeichen seines jeweiligen Eigentümers. Diese Seite ist nicht mit e-iceblue verbunden, genehmigt 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.