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

EO.Pdf vs. IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 8. Mai 2026

Wenn .NET-Entwickler nach Bibliotheken zur PDF-Erzeugung suchen, sticht EO.Pdf als kommerzielle Option mit Chromium-basierten Rendering-Funktionen hervor. Jedoch führen ihr größerer Bereitstellungsaufwand, Migrationsprobleme bei Legacy-Internet Explorer und der statische globale Konfigurationsansatz viele Teams dazu, Alternativen in Betracht zu ziehen.IronPDF bietet eine verfeinerte Chromium-Implementierung mit optimierter Verpackung, konfigurationssicherer Instanz und echter plattformübergreifender Unterstützung.

In diesem Vergleich werden beide Bibliotheken in Bezug auf technisch relevante Aspekte geprüft, um professionellen Entwicklern und Architekten dabei zu helfen, fundierte Entscheidungen für ihre .NET-PDF-Anforderungen zu treffen.

EO.Pdf besser verstehen

EO.Pdf ist eine kommerzielle PDF-Bibliothek, die zum Preis von $liteLicense pro Entwicklerlizenz angeboten wird und Chromium-basiertes Rendering für die hochwertige PDF-Erstellung bietet. Die Bibliothek basiert auf einer benutzerdefinierten Engine, die von ihrer ursprünglichen Internet Explorer-Rendering-Grundlage auf ein Chromium-basiertes System umgestellt wurde.

Trotz dieses Updates hat der Wechsel der Bibliothek zu Chromium aufgrund des Legacy-Erbes aus der Internet-Explorer-Ära Kompatibilitätsprobleme eingeführt. Es beinhaltet seine eigene Chromium-Engine, die zu einem größeren Bereitstellungsaufwand führt, was die Größe der Docker-Images erhöht, CI/CD-Pipelines verlangsamt und Infrastrukturkosten anhebt.

Auch wenn sich EO.Pdf selbst als plattformübergreifendes Tool vermarktet, sind seine Leistung und Benutzerfreundlichkeit in erster Linie auf Windows ausgerichtet, wobei die Linux-Unterstützung oft als zweitrangig beschrieben wird. Der Konverter verwendet statisches HtmlToPdf.Options für die Konfiguration, was in Multi-Tenant-Webanwendungen Probleme mit der Thread-Sicherheit verursacht.

IronPDF verstehen

IronPDF ist eine .NET-PDF-Bibliothek, die für moderne .NET-Umgebungen mit einem optimierten Chromium-Verpackungsansatz entwickelt wurde, um eine geringere Bereitstellungsgröße zu erzielen. Die Bibliothek unterstützt alle Plattformen gleichermaßen und bevorzugt nicht Windows, so dass sie sich für Anwendungen eignet, die in unterschiedlichen Umgebungen eingesetzt werden.

IronPDF nutzt eine instanzbasierte Konfiguration durch ChromePdfRenderer Objekte, was einen thread-sicheren Betrieb in parallelen Szenarien gewährleistet. Jede Renderer-Instanz hält ihr eigenes RenderingOptions bereit, wodurch die Konfiguration von anderen Operationen isoliert wird.

Architektur- und Konfigurationsvergleich

Der grundlegende architektonische Unterschied zwischen diesen .NET-PDF-Bibliotheken liegt in ihrem Konfigurationsansatz und ihren Einsatzmerkmalen.

Aspekt	EO.Pdf	IronPDF
Paketgröße	Größerer Bereitstellungsaufwand	Optimierte Verpackung
Legacy-Probleme	IE-Migrationsgepäck	Saubere, moderne Codebasis
Windows, Linux, macOS, Docker, Azure, AWS.	Windows-orientiert	Echt plattformübergreifend
Konfiguration	Statisch/global	Instanzbasiert, thread-sicher
Preis	`$liteLicense`/Entwickler	Konkurrenzfähige Preise
API-Entwurf	Gemischt (HtmlToPdf + ACM)	Einheitlich, konsistent
Dokumentation	Beschränkt	Gründliche Anleitungen
Modernes .NET	.NET Standard	.NET 6/7/8/9+ nativ
Async-Unterstützung	Beschränkt	Vollständig async/await

Das Konfigurationsmodell stellt eine wichtige Unterscheidung dar. Die statische HtmlToPdf.Options der Bibliothek beeinflusst alle Konvertierungen global und führt zu Race Conditions in Multi-Thread-Anwendungen. Der instanzbasierte Ansatz von IronPDF gewährleistet eine isolierte Konfiguration pro Renderer.

Code-Vergleich: Gängige PDF-Operationen

HTML-zu-PDF-Konvertierung

Die Konvertierung von HTML-Inhalten in PDF zeigt die grundlegenden API-Unterschiede auf.

EO.Pdf:

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF generated from HTML.</p></body></html>";
        
        HtmlToPdf.ConvertHtml(html, "output.pdf");
        
        Console.WriteLine("PDF created successfully!");
    }
}

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF generated from HTML.</p></body></html>";
        
        HtmlToPdf.ConvertHtml(html, "output.pdf");
        
        Console.WriteLine("PDF created successfully!");
    }
}

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF generated from HTML.</p></body></html>"
        
        HtmlToPdf.ConvertHtml(html, "output.pdf")
        
        Console.WriteLine("PDF created successfully!")
    End Sub
End Module

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF generated from HTML.</p></body></html>"
        
        HtmlToPdf.ConvertHtml(html, "output.pdf")
        
        Console.WriteLine("PDF created successfully!")
    End Sub
End Module

IronPDF:

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

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

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

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully!")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully!")
    End Sub
End Module

Die Bibliothek verwendet eine statische HtmlToPdf.ConvertHtml() Methode, die direkt in einen Dateipfad speichert.IronPDF nutzt einen zweistufigen Ansatz: RenderHtmlAsPdf() gibt ein PdfDocument Objekt zurück, das weiter manipuliert werden kann, bevor SaveAs() aufgerufen wird. Dieses zweistufige Muster bietet mehr Flexibilität für Nachbearbeitungsvorgänge wie das Zusammenführen, Hinzufügen von Wasserzeichen oder das Anwenden von Sicherheitseinstellungen.

Für fortgeschrittene HTML-Rendering-Optionen lesen Sie bitte den Leitfaden zur Konvertierung von HTML in PDF.

URL zu PDF-Konvertierung

Das Erfassen von Webseiten als PDF-Dokumente zeigt ähnliche API-Muster.

EO.Pdf:

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        
        HtmlToPdf.ConvertUrl(url, "webpage.pdf");
        
        Console.WriteLine("PDF from URL created successfully!");
    }
}

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        
        HtmlToPdf.ConvertUrl(url, "webpage.pdf");
        
        Console.WriteLine("PDF from URL created successfully!");
    }
}

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim url As String = "https://www.example.com"
        
        HtmlToPdf.ConvertUrl(url, "webpage.pdf")
        
        Console.WriteLine("PDF from URL created successfully!")
    End Sub
End Module

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim url As String = "https://www.example.com"
        
        HtmlToPdf.ConvertUrl(url, "webpage.pdf")
        
        Console.WriteLine("PDF from URL created successfully!")
    End Sub
End Module

IronPDF:

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

class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        
        Console.WriteLine("PDF from URL created successfully!");
    }
}

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

class Program
{
    static void Main()
    {
        string url = "https://www.example.com";
        
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        
        Console.WriteLine("PDF from URL created successfully!");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim url As String = "https://www.example.com"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully!")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim url As String = "https://www.example.com"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully!")
    End Sub
End Module

Beide Bibliotheken bieten die Fähigkeit zur URL-zu-PDF-Konvertierung an, wobei EO.Pdf statisches ConvertUrl() und IronPDF instanzbasiertes RenderUrlAsPdf() verwendet. Es gilt die gleiche Unterscheidung zwischen Threads und Sicherheit.

Weitere Informationen zum URL-Rendering finden Sie in der URL to PDF-Dokumentation.

PDF Zusammenführungsvorgänge

Die Kombination mehrerer PDF-Dokumente veranschaulicht verschiedene Objektmodellansätze.

EO.Pdf:

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        PdfDocument doc1 = new PdfDocument("file1.pdf");
        PdfDocument doc2 = new PdfDocument("file2.pdf");
        
        PdfDocument mergedDoc = new PdfDocument();
        mergedDoc.Append(doc1);
        mergedDoc.Append(doc2);
        
        mergedDoc.Save("merged.pdf");
        
        Console.WriteLine("PDFs merged successfully!");
    }
}

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        PdfDocument doc1 = new PdfDocument("file1.pdf");
        PdfDocument doc2 = new PdfDocument("file2.pdf");
        
        PdfDocument mergedDoc = new PdfDocument();
        mergedDoc.Append(doc1);
        mergedDoc.Append(doc2);
        
        mergedDoc.Save("merged.pdf");
        
        Console.WriteLine("PDFs merged successfully!");
    }
}

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim doc1 As New PdfDocument("file1.pdf")
        Dim doc2 As New PdfDocument("file2.pdf")

        Dim mergedDoc As New PdfDocument()
        mergedDoc.Append(doc1)
        mergedDoc.Append(doc2)

        mergedDoc.Save("merged.pdf")

        Console.WriteLine("PDFs merged successfully!")
    End Sub
End Module

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim doc1 As New PdfDocument("file1.pdf")
        Dim doc2 As New PdfDocument("file2.pdf")

        Dim mergedDoc As New PdfDocument()
        mergedDoc.Append(doc1)
        mergedDoc.Append(doc2)

        mergedDoc.Save("merged.pdf")

        Console.WriteLine("PDFs merged successfully!")
    End Sub
End Module

IronPDF:

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

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("file1.pdf");
        var pdf2 = PdfDocument.FromFile("file2.pdf");
        
        var merged = PdfDocument.Merge(new List<PdfDocument> { pdf1, pdf2 });
        merged.SaveAs("merged.pdf");
        
        Console.WriteLine("PDFs merged successfully!");
    }
}

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

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("file1.pdf");
        var pdf2 = PdfDocument.FromFile("file2.pdf");
        
        var merged = PdfDocument.Merge(new List<PdfDocument> { pdf1, pdf2 });
        merged.SaveAs("merged.pdf");
        
        Console.WriteLine("PDFs merged successfully!");
    }
}

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

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("file1.pdf")
        Dim pdf2 = PdfDocument.FromFile("file2.pdf")
        
        Dim merged = PdfDocument.Merge(New List(Of PdfDocument) From {pdf1, pdf2})
        merged.SaveAs("merged.pdf")
        
        Console.WriteLine("PDFs merged successfully!")
    End Sub
End Module

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

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("file1.pdf")
        Dim pdf2 = PdfDocument.FromFile("file2.pdf")
        
        Dim merged = PdfDocument.Merge(New List(Of PdfDocument) From {pdf1, pdf2})
        merged.SaveAs("merged.pdf")
        
        Console.WriteLine("PDFs merged successfully!")
    End Sub
End Module

Diese Lösung lädt Dokumente über Konstruktoren (new PdfDocument(path)) und verwendet Append(), um Dokumente zu einem leeren Container hinzuzufügen.IronPDF verwendet statische Fabrikmethoden (PdfDocument.FromFile()) und eine statische PdfDocument.Merge() Methode, die eine Sammlung akzeptiert und das zusammengeführte Ergebnis zurückgibt.

Weitere Zusammenführungsoperationen finden Sie in der PDF-Merge-Dokumentation.

Benutzerdefinierte Seiteneinstellungen

Die Konfiguration von Seitengröße und Rändern zeigt die Unterschiede im Konfigurationsmodell auf.

EO.Pdf:

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        HtmlToPdfOptions options = new HtmlToPdfOptions();
        options.PageSize = PdfPageSizes.A4;
        options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);
        
        HtmlToPdf.ConvertUrl("file:///C:/input.html", "output.pdf", options);
        Console.WriteLine("PDF with custom settings created.");
    }
}

// NuGet: Install-Package EO.Pdf
using EO.Pdf;
using System;

class Program
{
    static void Main()
    {
        HtmlToPdfOptions options = new HtmlToPdfOptions();
        options.PageSize = PdfPageSizes.A4;
        options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);
        
        HtmlToPdf.ConvertUrl("file:///C:/input.html", "output.pdf", options);
        Console.WriteLine("PDF with custom settings created.");
    }
}

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim options As New HtmlToPdfOptions()
        options.PageSize = PdfPageSizes.A4
        options.OutputArea = New RectangleF(0.5F, 0.5F, 7.5F, 10.5F)
        
        HtmlToPdf.ConvertUrl("file:///C:/input.html", "output.pdf", options)
        Console.WriteLine("PDF with custom settings created.")
    End Sub
End Module

' NuGet: Install-Package EO.Pdf
Imports EO.Pdf
Imports System

Module Program
    Sub Main()
        Dim options As New HtmlToPdfOptions()
        options.PageSize = PdfPageSizes.A4
        options.OutputArea = New RectangleF(0.5F, 0.5F, 7.5F, 10.5F)
        
        HtmlToPdf.ConvertUrl("file:///C:/input.html", "output.pdf", options)
        Console.WriteLine("PDF with custom settings created.")
    End Sub
End Module

IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        
        var pdf = renderer.RenderHtmlFileAsPdf("C:/input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF with custom settings created.");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        
        var pdf = renderer.RenderHtmlFileAsPdf("C:/input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF with custom settings created.");
    }
}

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

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20

        Dim pdf = renderer.RenderHtmlFileAsPdf("C:/input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF with custom settings created.")
    End Sub
End Module

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

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20

        Dim pdf = renderer.RenderHtmlFileAsPdf("C:/input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF with custom settings created.")
    End Sub
End Module

Der Konverter verwendet HtmlToPdfOptions mit OutputArea als RectangleF in Zoll angegeben.IronPDF verwendet individuelle Randeigenschaften (MarginTop, MarginBottom, MarginLeft, MarginRight) in Millimetern auf dem RenderingOptions Objekt. Der Unterschied in den Einheiten erfordert eine Umrechnung: inches × 25.4 = millimeters.

Referenz zur Methodenzuordnung

Für Entwickler, die eine EO.Pdf-Migration oder einen Vergleich von Funktionen prüfen, zeigt diese Zuordnung gleichwertige Operationen:

Kerngeschäft

EO.Pdf	IronPDF
`HtmlToPdf.ConvertHtml(html, path)`	`renderer.RenderHtmlAsPdf(html)` dann `SaveAs()`
`HtmlToPdf.ConvertUrl(url, path)`	`renderer.RenderUrlAsPdf(url)` dann `SaveAs()`
`HtmlToPdf.Options.PageSize`	`renderer.RenderingOptions.PaperSize`
`HtmlToPdf.Options.OutputArea`	`MarginTop/Bottom/Left/Right`
`new PdfDocument(path)`	`PdfDocument.FromFile(path)`
`doc.Append(other)`	`PdfDocument.Merge(doc1, doc2)`
`doc.Save(path)`	`pdf.SaveAs(path)`

Konfigurations-Mapping

EO.Pdf-Option	IronPDF RenderingOptionen
`Options.PageSize = PdfPageSizes.A4`	`PaperSize = PdfPaperSize.A4`
`Options.PageSize = PdfPageSizes.Letter`	`PaperSize = PdfPaperSize.Letter`
`Options.OutputArea` (RectangleF)	`MarginTop`, `MarginBottom`, etc.
`Options.BaseUrl`	`BaseUrl`

Klassenzuordnung

EO.Pdf-Klasse	IronPDF-Äquivalent
`HtmlToPdf`	`ChromePdfRenderer`
`PdfDocument`	`PdfDocument`
`HtmlToPdfOptions`	`ChromePdfRenderOptions`
`AcmRender`	Nicht erforderlich
`AcmText`	HTML `<span>`, `<p>`
`AcmBlock`	HTML `<div>`

Zusammenfassung des Funktionsvergleichs

Feature	EO.Pdf	IronPDF
HTML zu PDF	Ja	Ja
URL zu PDF	Ja	Ja
PDF-Zusammenführung	Ja	Ja
Seitenmanipulation	Ja	Ja
Kopfzeilen/Fußzeilen	Ja	Ja (HTML-basiert)
Sicherheit/Verschlüsselung	Ja	Ja
Formularfelder	Ja	Ja
Wasserzeichen	Ja	Ja
ACM-Rendering	Ja	HTML/CSS (kein ACM)
Thread-sichere Konfiguration	Ja (pro Thread isoliert)	Ja (Instanz)
Plattformübergreifend	Beschränkt	Unterstützt

Das Problem der Thread-Sicherheit

Die statische Konfiguration von EO.Pdf führt zu einem grundsätzlichen Problem bei Multithreading-Anwendungen:

// EO.Pdf - DANGER: Static options affect ALL threads!
HtmlToPdf.Options.PageSize = PdfPageSizes.A4;
HtmlToPdf.Options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);
HtmlToPdf.ConvertHtml(html, "output.pdf");

// EO.Pdf - DANGER: Static options affect ALL threads!
HtmlToPdf.Options.PageSize = PdfPageSizes.A4;
HtmlToPdf.Options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);
HtmlToPdf.ConvertHtml(html, "output.pdf");

' EO.Pdf - DANGER: Static options affect ALL threads!
HtmlToPdf.Options.PageSize = PdfPageSizes.A4
HtmlToPdf.Options.OutputArea = New RectangleF(0.5F, 0.5F, 7.5F, 10.5F)
HtmlToPdf.ConvertHtml(html, "output.pdf")

' EO.Pdf - DANGER: Static options affect ALL threads!
HtmlToPdf.Options.PageSize = PdfPageSizes.A4
HtmlToPdf.Options.OutputArea = New RectangleF(0.5F, 0.5F, 7.5F, 10.5F)
HtmlToPdf.ConvertHtml(html, "output.pdf")

In einer Webanwendung, die mehrere gleichzeitige Anfragen verarbeitet, wirkt sich die Konfiguration einer Anfrage auf alle anderen Anfragen aus. Dadurch entstehen Wettlaufbedingungen, bei denen PDFs mit unerwarteten Einstellungen erzeugt werden können.

Der instanzbasierte Ansatz von IronPDF beseitigt dieses Problem:

//IronPDF- Thread-safe, isolated options per renderer instance
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 12.7;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

//IronPDF- Thread-safe, isolated options per renderer instance
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 12.7;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

'IronPDF- Thread-safe, isolated options per renderer instance
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 12.7
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

'IronPDF- Thread-safe, isolated options per renderer instance
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 12.7
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Jede ChromePdfRenderer Instanz hält ihre eigene Konfiguration bereit, um Isolation in parallelen Szenarien zu gewährleisten.

Wenn Teams den Wechsel von EO.Pdf zu IronPDF erwägen

Entwicklungsteams erwägen den Umstieg von EO.Pdf auf IronPDF aus mehreren Gründen:

Optimierung der Paketgröße: EO.Pdf's größerer Bereitstellungsaufwand bläht Docker-Images auf, verlangsamt CI/CD-Pipelines und erhöht Infrastrukturkosten. IronPDFs optimierte Verpackung sorgt für Effizienzsteigerungen bei der Bereitstellung.

Thread-Sicherheitsanforderungen: Multi-Tenant-Webanwendungen erfordern isolierte Konfigurationen pro Anfrage. Die statische HtmlToPdf.Options der Bibliothek schafft Race Conditions, die durch IronPDFs instanzbasierten Ansatz beseitigt werden.

Plattformübergreifender Einsatz: Anwendungen, die auf Linux- oder macOS-Umgebungen abzielen, stoßen auf Einschränkungen durch das Windows-zentrierte Design von EO.Pdf.IronPDF bietet echte plattformübergreifende Unterstützung mit konsistentem Verhalten.

Vermeidung von Legacy-Erbe: Der Übergang von Internet Explorer zu Chromium führte zu Kompatibilitätsproblemen. Die saubere, moderne Codebasis von IronPDF vermeidet diese technische Verschuldung.

Moderne .NET-Unterstützung: Anwendungen, die auf .NET 6/7/8/9+ ausgerichtet sind, profitieren von IronPDFs nativer Unterstützung im Gegensatz zu EO.Pdfs Ausrichtung auf .NET Standard.

ACM-Migration: Teams, die das Advanced Content Model (ACM) von EO.Pdf (AcmRender, AcmText, AcmBlock) verwenden, finden den HTML/CSS-Ansatz von IronPDF einfacher und wartungsfreundlicher.

Stärken und Überlegungen

EO.Pdf Stärken

Chromium Rendering: Hochwertige W3C-konforme Ausgabe
Etablierte Bibliothek: Bewährt in Produktionsumgebungen
Einstufige Konversion: Direkter Datei-Output via ConvertHtml()

EO.Pdf Überlegungen

Massive Paketgröße: 126 MB Bereitstellungsbedarf
Legacy IE Baggage: Kompatibilitätsprobleme durch Migration
Statische Konfiguration: Probleme mit der Thread-Sicherheit in mandantenfähigen Anwendungen
Windows-zentriert: Begrenzte Unterstützung für Linux/macOS
Preis: $liteLicense pro Entwicklerlizenz
Beschränkte Dokumentation: Weniger Tutorials und Beispiele

IronPDF Stärken

Optimierter Platzbedarf: ~50MB Paketgröße (50% kleiner)
Echte plattformübergreifende Lösung: Windows, Linux, macOS, Docker
Threadsichere Konfiguration: Instanzbasierte Renderer-Optionen
Modernes API: Konsistente, intuitive Methodennamen
Aktive Entwicklung: Regelmäßige Updates und Sicherheitspatches
Umfassende Ressourcen: Umfangreiche Tutorials und Dokumentation

IronPDF Überlegungen

Zweistufiges Speichern: Render gibt PdfDocument zurück, dann Aufruf von SaveAs()
Unterschiede zwischen den Einheiten: Verwendet Millimeter für Ränder (im Gegensatz zu EO.Pdf Zoll)

Abschluss

EO.Pdf und IronPDF bieten beide eine Chromium-basierte PDF-Generierung for .NET-Entwickler, verfolgen aber unterschiedliche Architekturansätze. EO.Pdf bietet bewährte Funktionen, hat aber eine Paketgröße von 126 MB, veraltete Internet Explorer-Migrationsdaten und eine unsichere statische Konfiguration.

IronPDF bietet eine moderne Alternative mit optimierter Paketierung, echter plattformübergreifender Unterstützung und instanzbasierter, thread-sicherer Konfiguration. Für Teams, die eine effiziente Bereitstellung, die Sicherheit des gleichzeitigen Betriebs oder eine plattformübergreifende Ausrichtung benötigen, erfüllt IronPDF diese spezifischen Anforderungen.

Da Unternehmen for .NET 10, C# 14 und die Anwendungsentwicklung bis 2026 planen, hängt die Wahl von bestimmten Prioritäten ab. Teams mit bestehenden EO.Pdf-Implementierungen in Single-Thread-Windows-Umgebungen können dort weiterhin von Nutzen sein. Für moderne mandantenfähige Anwendungen, containerisierte Bereitstellungen oder plattformübergreifende Anforderungen bietet IronPDF einen geeigneteren Ansatz.

Testen Sie IronPDF mit einer kostenlosen Testversion und lesen Sie die umfassende Dokumentation, um die Eignung für Ihre spezifischen Anforderungen zu prüfen.