Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von eo.pdf zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von EO.Pdf zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

EO.Pdf stellt mehrere architektonische Herausforderungen dar, die Entwicklungsteams dazu veranlassen, Alternativen zu bewerten. Das Verständnis dieser Aspekte ist für die Planung Ihrer Migrationsstrategie unerlässlich.

Die EO.Pdf-Probleme

  1. Enorme Paketgröße von 126 MB: EO.Pdf bündelt seine eigene Chromium-Engine, was zu einer Installationsgröße von 126 MB führt. Dies bläht Docker-Images auf, verlangsamt CI/CD-Pipelines und erhöht die Infrastrukturkosten.

  2. Altlasten der Architektur: EO.Pdf wurde ursprünglich auf der Rendering-Engine des Internet Explorers erstellt, bevor es auf Chromium migriert wurde. Dieses Erbe bringt Kompatibilitätsprobleme aus der IE-Ära, technische Schulden im API-Design und inkonsistentes Verhalten zwischen den Versionen mit sich.

  3. Windows-zentriertes Design: Trotz der Vermarktung als "plattformübergreifend" ist die Unterstützung für Linux und macOS bei EO.Pdf eingeschränkt. Viele Entwickler berichten über Probleme mit Nicht-Windows-Implementierungen.

  4. Statische globale Optionen: EO.Pdf verwendet statische HtmlToPdf.Options für die Konfiguration, was nicht threadsicher und in mandantenfähigen Webanwendungen problematisch ist.

  5. 799 US-Dollar pro Lizenz: Mit 799 US-Dollar pro Entwicklerlizenz ist EO.Pdf im Vergleich zu Alternativen mit ähnlicher oder besserer Funktionalität teuer.

Architektur-Vergleich

Aspekt EO.Pdf IronPDF
Paketgröße 126MB Optimiert (~50MB)
Legacy-Probleme IE-Migrationsgepäck Saubere, moderne Codebasis
Plattform-Unterstützung Windows-orientiert Echt plattformübergreifend
Konfiguration Statisch/global (nicht thread-sicher) Instanzbasiert, thread-sicher
API-Entwurf Gemischt (HtmlToPdf + ACM) Einheitlich, konsistent
Dokumentation Beschränkt Umfassende Tutorials
Modernes .NET .NET Standard .NET 6/7/8/9+ nativ
Async-Unterstützung Beschränkt Vollständig async/await

Wichtige Vorteile der Migration

  1. 50 % kleinerer Platzbedarf: Die optimierte Chromium-Verpackung von IronPDF.
  2. Echte Plattformunabhängigkeit: Funktioniert identisch unter Windows, Linux, macOS und Docker.
  3. Thread-sichere Konfiguration: Instanzbasierte Renderer-Optionen
  4. Moderne API: Einheitliche, intuitive Methodennamen
  5. Bessere Dokumentation: Umfangreiche Tutorials und Beispiele

Vorbereitung auf die Migration

Voraussetzungen

Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:

  • .NET Framework 4.6.2+ oder .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ oder VS Code mit C#-Erweiterung
  • NuGet Package Manager Zugang
  • IronPDF-Lizenzschlüssel (kostenlose Testversion erhältlich unter ironpdf.com)

Audit EO.Pdf Verwendung

Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus, um alle EO.Pdf-Referenzen zu identifizieren:

# Find all EO.Pdf references
grep -r "EO.Pdf\|HtmlToPdf\|AcmRender\|PdfDocument" --include="*.cs" .

# Check NuGet packages
dotnet list package | grep -i "EO.Pdf"
# Find all EO.Pdf references
grep -r "EO.Pdf\|HtmlToPdf\|AcmRender\|PdfDocument" --include="*.cs" .

# Check NuGet packages
dotnet list package | grep -i "EO.Pdf"
SHELL

Häufige EO.Pdf-Namensräume, nach denen Sie suchen sollten:

  • EO.Pdf - Core HTML zu PDF
  • EO.Pdf.Acm - Erweitertes Inhaltsmodell (ACM)
  • EO.Pdf.Contents - Manipulation von Inhalten auf niedriger Ebene
  • EO.Pdf.Drawing - Grafikoperationen

Verständnis der Core Pattern Änderung

Der wichtigste architektonische Unterschied zwischen EO.Pdf und IronPDF ist der Konfigurationsumfang. EO.Pdf verwendet statische Methoden mit globalen Optionen, die sich auf alle Konvertierungen auswirken - ein Muster, das in Webanwendungen Probleme mit der Thread-Sicherheit verursacht.IronPDF verwendet instanzbasierte Renderer mit lokalen Optionen, um sicherzustellen, dass jede Konvertierung isoliert ist.

Schritt-für-Schritt-Migrationsprozess

Schritt 1: NuGet-Pakete aktualisieren

Entfernen Sie EO.Pdf und installieren Sie IronPDF:

# Remove EO.Pdf
dotnet remove package EO.Pdf

# Install IronPDF
dotnet add package IronPdf
# Remove EO.Pdf
dotnet remove package EO.Pdf

# Install IronPDF
dotnet add package IronPdf
SHELL

Schritt 2: Namensraumreferenzen aktualisieren

Ersetzen Sie die Namensräume von EO.Pdf durch IronPDF:

// Remove these
using EO.Pdf;
using EO.Pdf.Acm;

// Add this
using IronPdf;
// Remove these
using EO.Pdf;
using EO.Pdf.Acm;

// Add this
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 3: Lizenz konfigurieren

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Komplette API-Migrationsreferenz

Kernklassen-Zuordnung

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

Methoden-Mapping

EO.Pdf-Methode IronPDF-Methode
HtmlToPdf.ConvertHtml(html, path) renderer.RenderHtmlAsPdf(html) dann SaveAs(path)
HtmlToPdf.ConvertUrl(url, path) renderer.RenderUrlAsPdf(url) dann SaveAs(path)
PdfDocument.Save(path) pdf.SaveAs(path)
new PdfDocument(path) PdfDocument.FromFile(path)
doc.Append(other) PdfDocument.Merge(doc1, doc2)

Optionen-Zuordnung

EO.Pdf-Option IronPDFRenderingOptionen
Options.PageSize = PdfPageSizes.A4 PaperSize = PdfPaperSize.A4
Options.OutputArea (RectangleF) MarginTop, MarginBottom, etc.

Beispiele für die Code-Migration

HTML-zu-PDF-Konvertierung

Die grundlegende HTML-zu-PDF-Konvertierung demonstriert den Wechsel von statischen Methoden zum instanzbasierten Rendering.

EO.Pdf Implementierung:

// 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!");
    }
}
Imports EO.Pdf
Imports System

Class Program
    Shared 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 Class
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

// 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!");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared 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 = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully!")
    End Sub
End Class
$vbLabelText   $csharpLabel

Das zweistufige Vorgehen von IronPDF(rendern, dann speichern) ermöglicht den Zugriff auf das PdfDocument-Objekt zur weiteren Bearbeitung vor dem Speichern. Weitere Optionen finden Sie in der HTML zu PDF Dokumentation.

URL zu PDF-Konvertierung

EO.Pdf Implementierung:

// 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!");
    }
}
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
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

// 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!");
    }
}
Imports IronPdf
Imports System

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

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

        Console.WriteLine("PDF from URL created successfully!")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF s RenderUrlAsPdf bietet vollständige JavaScript Ausführung und Unterstützung für modernes CSS. Weitere Optionen finden Sie in der URL zur PDF-Dokumentation.

HTML-Datei mit benutzerdefinierten Einstellungen

Dieses Beispiel verdeutlicht den entscheidenden Unterschied in den Konfigurationsmustern – EO.Pdf's OutputArea mit Zollangaben versus IronPDF's individuelle Randeigenschaften in Millimetern.

EO.Pdf Implementierung:

// 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.");
    }
}
Imports EO.Pdf
Imports System

Class Program
    Shared 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 Class
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

// 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.");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Program
    Shared 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 Class
$vbLabelText   $csharpLabel

Beachten Sie die Einheitenumrechnung: EO.Pdf verwendet Zoll in OutputArea, während IronPDFMillimeter verwendet. Konvertieren mit: inches × 25.4 = mm. Weitere Optionen finden Sie in der Dokumentation der Rendering-Optionen.

Mehrere PDFs zusammenführen

Das Zusammenführen von PDFs verdeutlicht den Unterschied zwischen dem Schleifenmuster Append von EO.Pdf und der statischen Methode Merge von IronPDF.

EO.Pdf Implementierung:

// 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!");
    }
}
Imports EO.Pdf
Imports System

Class Program
    Shared 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 Class
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

// 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!");
    }
}
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
$vbLabelText   $csharpLabel

Die statische Methode Merge von IronPDF akzeptiert eine Sammlung von Dokumenten und vereinfacht so das Zusammenführen mehrerer Dokumente. Beachten Sie den Wechsel vom Konstruktor (new PdfDocument(path)) zur statischen Factory (PdfDocument.FromFile(path)). Weitere Optionen finden Sie in der Dokumentation zum Zusammenführen von PDFs .

Kritische Hinweise zur Migration

Umrechnung von Maßeinheiten

EO.Pdf verwendet Zoll in OutputArea.IronPDF arbeitet mit Millimetern. Konvertieren mit: inches × 25.4 = mm

// EO.Pdf - 0.5 inch margins
options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);

//IronPDF- equivalent in millimeters (0.5" = 12.7mm)
renderer.RenderingOptions.MarginTop = 12.7;
renderer.RenderingOptions.MarginBottom = 12.7;
renderer.RenderingOptions.MarginLeft = 12.7;
renderer.RenderingOptions.MarginRight = 12.7;
// EO.Pdf - 0.5 inch margins
options.OutputArea = new RectangleF(0.5f, 0.5f, 7.5f, 10.5f);

//IronPDF- equivalent in millimeters (0.5" = 12.7mm)
renderer.RenderingOptions.MarginTop = 12.7;
renderer.RenderingOptions.MarginBottom = 12.7;
renderer.RenderingOptions.MarginLeft = 12.7;
renderer.RenderingOptions.MarginRight = 12.7;
' EO.Pdf - 0.5 inch margins
options.OutputArea = New RectangleF(0.5F, 0.5F, 7.5F, 10.5F)

' IronPDF- equivalent in millimeters (0.5" = 12.7mm)
renderer.RenderingOptions.MarginTop = 12.7
renderer.RenderingOptions.MarginBottom = 12.7
renderer.RenderingOptions.MarginLeft = 12.7
renderer.RenderingOptions.MarginRight = 12.7
$vbLabelText   $csharpLabel

Statische zu instanzbasierter Konfiguration

Ersetzen Sie alle HtmlToPdf.Options.X durch renderer.RenderingOptions.X:

// EO.Pdf - static options (NOT thread-safe!)
HtmlToPdf.Options.PageSize = PdfPageSizes.A4;

//IronPDF- instance options (thread-safe)
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
// EO.Pdf - static options (NOT thread-safe!)
HtmlToPdf.Options.PageSize = PdfPageSizes.A4;

//IronPDF- instance options (thread-safe)
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
' EO.Pdf - static options (NOT thread-safe!)
HtmlToPdf.Options.PageSize = PdfPageSizes.A4

' IronPDF- instance options (thread-safe)
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
$vbLabelText   $csharpLabel

ACM zu HTML Migration

Wenn Sie das erweiterte Inhaltsmodell von EO.Pdf (AcmRender, AcmText, AcmBlock) verwenden, migrieren Sie zu Standard-HTML/CSS:

// EO.Pdf ACM approach
var acmContent = new AcmContent();
acmContent.Add(new AcmText("Sample Text"));

//IronPDFHTML approach
var html = "<div>Sample Text</div>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// EO.Pdf ACM approach
var acmContent = new AcmContent();
acmContent.Add(new AcmText("Sample Text"));

//IronPDFHTML approach
var html = "<div>Sample Text</div>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
' EO.Pdf ACM approach
Dim acmContent As New AcmContent()
acmContent.Add(New AcmText("Sample Text"))

' IronPDFHTML approach
Dim html As String = "<div>Sample Text</div>"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Zweistufiges Speichermuster

EO.Pdf speichert direkt in ConvertHtml().IronPDF gibt ein PdfDocument-Objekt zurück, dann rufen Sie SaveAs() auf:

// EO.Pdf - one step
HtmlToPdf.ConvertHtml(html, "output.pdf");

//IronPDF- two steps (enables manipulation before save)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// EO.Pdf - one step
HtmlToPdf.ConvertHtml(html, "output.pdf");

//IronPDF- two steps (enables manipulation before save)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
' EO.Pdf - one step
HtmlToPdf.ConvertHtml(html, "output.pdf")

' IronPDF- two steps (enables manipulation before save)
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Konstruktor zu statischer Fabrik

Ersetzen Sie new PdfDocument(path) durch PdfDocument.FromFile(path):

// EO.Pdf
var doc = new PdfDocument("file.pdf");

// IronPDF
var doc = PdfDocument.FromFile("file.pdf");
// EO.Pdf
var doc = new PdfDocument("file.pdf");

// IronPDF
var doc = PdfDocument.FromFile("file.pdf");
' EO.Pdf
Dim doc = New PdfDocument("file.pdf")

' IronPDF
Dim doc = PdfDocument.FromFile("file.pdf")
$vbLabelText   $csharpLabel

Post-Migrations-Checkliste

Überprüfen Sie nach Abschluss der Codemigration Folgendes:

  • Visueller Vergleich der generierten PDFs
  • Überprüfen Sie, ob Kopf- und Fußzeilen korrekt dargestellt werden.
  • Sicherheits-/Verschlüsselungseinstellungen testen
  • Zusammenführungsvorgänge validieren
  • Leistungsvergleich
  • Plattformübergreifende Tests (Windows, Linux, macOS)
  • Entfernen Sie die EO.Pdf-Lizenzdateien.
  • Dokumentation aktualisieren

Zukunftssicherheit für Ihre PDF-Infrastruktur

Mit .NET 10 am Horizont und C# 14, das neue Sprachfunktionen einführt, stellt die Wahl einer PDF-Bibliothek mit moderner nativer .NET-Unterstützung die langfristige Kompatibilität sicher. Die instanzbasierte, thread-sichere Architektur von IronPDF entspricht modernen Webanwendungsmustern - besonders wichtig für mandantenfähige SaaS-Anwendungen, bei denen die statischen globalen Optionen von EO.Pdf zu Gleichzeitigkeitsproblemen führen.

Zusätzliche Ressourcen

Durch die Migration von EO.Pdf zu IronPDF werden die 126 MB großen Pakete, die Altlasten aus der IE-Ära und die Bedenken hinsichtlich der Thread-Sicherheit durch statische globale Optionen beseitigt. Der Übergang zur instanzbasierten Konfiguration stellt sicher, dass Ihr PDF-Generierungscode in Webanwendungen mit mehreren Threads zuverlässig funktioniert und gleichzeitig eine echte plattformübergreifende Bereitstellung unterstützt.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an