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

Migrieren von XFINIUM.PDF zu IronPDF in C#

Curtis Chau
Curtis Chau
Aktualisiert:

XFINIUM.PDF ist eine plattformübergreifende PDF-Bibliothek, die umfassende Werkzeuge für die programmgesteuerte Erstellung und Bearbeitung von PDFs in C# bietet. Die Bibliothek bietet zwar zwei Editionen - Generator und Viewer -, aber die Tatsache, dass sie auf koordinatenbasierter Grafikprogrammierung beruht, stellt Entwicklerteams, die dokumentenlastige Anwendungen erstellen, vor große Herausforderungen. Jedes Element muss manuell mit Hilfe von Pixelkoordinaten positioniert werden, wodurch die eigentlich einfachen Dokumente zu komplexen Zeichenübungen werden.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von XFINIUM.PDF zu IronPDF, mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von XFINIUM.PDF migrieren

XFINIUM.PDF ist eine Low-Level-PDF-Bibliothek, die auf koordinatenbasierter Grafikprogrammierung beruht und Entwickler dazu zwingt, jedes Element manuell auf der Seite zu positionieren. Dieser Ansatz wird zu einem Alptraum für die Wartung, wenn sich die Anforderungen ändern. Zu den wichtigsten Gründen, warum Entwicklerteams eine Migration in Betracht ziehen, gehören:

Keine HTML-Unterstützung: XFINIUM.PDF kann HTML/CSS nicht direkt in PDF konvertieren. Der Schwerpunkt liegt auf der programmatischen PDF-Erstellung mit Low-Level-Zeichenprimitiven, die für Projekte, die umfangreiche HTML-zu-PDF-Funktionen erfordern, möglicherweise nicht ausreichen.

Koordinatenbasierte API: Für jedes Element auf der Seite ist eine manuelle Positionierung mit Pixelkoordinaten wie DrawString("text", font, brush, 50, 100) erforderlich.

Manuelle Schriftartenverwaltung: Schriftartobjekte müssen explizit mit Klassen wie PdfStandardFont und PdfBrush erstellt und verwaltet werden.

Kein CSS-Styling: Keine Unterstützung für modernes Web-Styling. Farben, Schriftarten und Layouts müssen manuell durch programmatische Methodenaufrufe gehandhabt werden.

Kein JavaScript Rendering: Nur statischer Inhalt. XFINIUM.PDF kann keine dynamischen Webinhalte darstellen oder JavaScript ausführen.

Komplexes Textlayout: Für alles, was über einfache einzeilige Texte hinausgeht, sind manuelle Textmessung und Umbruchberechnungen erforderlich.

Begrenzte Community-Ressourcen: Im Vergleich zu gängigen Lösungen mangelt es an von der Community bereitgestellten Ressourcen wie Beispielen und Tutorials, was es neuen Benutzern erschweren kann, loszulegen.

Das Kernproblem: Grafik-API vs. HTML

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

// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
' XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50)
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80)
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80)
' ... hundreds of lines for a simple document
$vbLabelText   $csharpLabel

IronPDF verwendet vertrautes HTML/CSS:

// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Declarative HTML
Dim html As String = "<h1>Invoice</h1><p><b>Customer:</b> " & customer.Name & "</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDF vs. XFINIUM.PDF: Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

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
CSS-Unterstützung No Vollständig CSS3
JavaScript No Vollständiger ES2024
Flexbox/Grid No Yes
Automatisches Layout No Yes
Automatische Seitenumbrüche No Yes
Handbuch Positionierung Erforderlich Optional (CSS-Positionierung)
Lernkurve Hoch (Koordinatensystem) Niedrig (HTML/CSS)
Code Verbosity Sehr hoch Niedrig

Schnellstart: XFINIUM.PDF zu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen des NuGet-Pakets

XFINIUM.PDF entfernen:

# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
SHELL

IronPDF installieren:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie die XFINIUM.PDF-Namensräume durch den IronPDF-Namensraum:

// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// After (IronPDF)
using IronPdf;
// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Der grundlegendste Vorgang offenbart den Komplexitätsunterschied zwischen diesen .NET-PDF-Bibliotheken.

XFINIUM.PDF-Ansatz:

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

IronPDF-Ansatz:

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

Class Program
    Shared Sub Main()
        Dim renderer = 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 Class
$vbLabelText   $csharpLabel

XFINIUM.PDF erfordert das Erstellen eines PdfFixedDocument, eines PdfFlowDocument, eines PdfFlowContent Objekts, den Aufruf von AppendHtml(), das Hinzufügen von Inhalten zum Flow-Dokument, das Rendern zum Fixed-Dokument und schließlich das Speichern.IronPDF vereinfacht dies auf drei Zeilen: einen Renderer erstellen, HTML rendern und speichern.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Mehrere PDFs zusammenführen

Die PDF-Zusammenführung zeigt die Unterschiede in der API-Komplexität deutlich auf.

XFINIUM.PDF-Ansatz:

// 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();
    }
}
Imports Xfinium.Pdf
Imports System.IO

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

IronPDF-Ansatz:

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

XFINIUM.PDF erfordert die Erstellung eines Ausgabedokuments, das Öffnen von Dateistreams, das Laden jedes Dokuments, die manuelle Iteration durch die Seiten und das Hinzufügen einer Seite nach der anderen, das Speichern und das Schließen der Streams.IronPDF bietet eine einzige PdfDocument.Merge() Methode, die die gesamte Komplexität intern handhabt.

In der PDF-Zusammenführungsdokumentation finden Sie weitere Zusammenführungsoptionen.

Erstellen von PDFs mit Text und Bildern

Dokumente mit gemischtem Inhalt zeigen den grundlegenden Paradigmenunterschied.

XFINIUM.PDF-Ansatz:

// 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");
    }
}
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
Imports Xfinium.Pdf.Core
Imports System.IO

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

IronPDF-Ansatz:

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

Class Program
    Shared Sub Main()
        Dim renderer = 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 Class
$vbLabelText   $csharpLabel

XFINIUM.PDF erfordert das Erstellen eines Dokuments, das Hinzufügen einer Seite, das Erstellen von Schriftart- und Pinselobjekten, das Zeichnen von Text an bestimmten Koordinaten, das Öffnen eines Bildstreams, das Erstellen eines PdfJpegImage, das Zeichnen des Bildes an Koordinaten mit Abmessungen, das Schließen des Streams und das Speichern. IronPDF verwendet Standard-HTML mit eingebetteten base64-Bildern - der gleiche Ansatz, den Webentwickler täglich verwenden.

XFINIUM.PDF API zu IronPDF Mapping-Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

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 on <div>
PdfStandardFont CSS font-family
PdfRgbColor CSS color
PdfBrush CSS-Eigenschaften
PdfJpegImage <img> Tag mit Base64
document.Save(stream) pdf.SaveAs() oder pdf.BinaryData
PdfFlowDocument RenderHtmlAsPdf()
PdfFlowContent.AppendHtml() RenderHtmlAsPdf()

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: Koordinatenbasiertes Layout

XFINIUM.PDF: Alles erfordert genaue X,Y-Koordinaten mit manueller Positionierung.

Lösung: Verwenden Sie HTML/CSS-Flow-Layout. Verwenden Sie bei Bedarf CSS für die absolute Positionierung:

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

Ausgabe 2: Font-Objekt-Verwaltung

XFINIUM.PDF: Erstellen Sie für jede Schriftart PdfStandardFont- oder PdfUnicodeTrueTypeFont-Objekte.

Lösung: Verwenden Sie CSS font-family - Schriftarten werden automatisch behandelt:

<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

Ausgabe 3: Farbverarbeitung

XFINIUM.PDF: Erstellen Sie PdfRgbColor und PdfBrush Objekte für Farben.

Lösung: Verwenden Sie Standard-CSS-Farben:

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

Ausgabe 4: Manuelle Seitenumbrüche

XFINIUM.PDF: Verfolgen Sie die Y-Position und erstellen Sie manuell neue Seiten, wenn der Inhalt überläuft.

Lösung:IronPDF sorgt für automatische Seitenumbrüche. Verwenden Sie CSS zur eindeutigen Steuerung:

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

Ausgabe 5: Laden von Bildern

XFINIUM.PDF: Dateistreams öffnen, PdfJpegImage Objekte erstellen, an Koordinaten zeichnen, Streams schließen.

Lösung: Verwenden Sie HTML-Tags <img> mit Dateipfaden oder Base64-Daten:

<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
HTML

XFINIUM.PDF Migration Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von XFINIUM.PDF zu identifizieren:

grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
SHELL

Dokumentieren Sie koordinatenbasierte Layouts und notieren Sie alle X,Y-Positionierungswerte. Identifiziere Schriftart- und Farbobjekte (PdfStandardFont, PdfRgbColor, PdfBrush). Zusammengeführte PDF-Workflows mithilfe von PdfFixedDocument.Pages.Add().

Aufgaben der Code-Aktualisierung

  1. Xfinium.Pdf NuGet-Paket entfernen
  2. IronPDF NuGet-Paket installieren
  3. Namespace-Importe von Xfinium.Pdf auf IronPdf aktualisieren
  4. Konvertieren Sie DrawString()-Aufrufe in HTML-Textelemente.
  5. Konvertieren Sie DrawImage()-Aufrufe in HTML-<img>-Tags
  6. Konvertiere DrawRectangle() und DrawLine() in CSS-Rahmen.
  7. Ersetzen Sie PdfStandardFont durch CSS font-family
  8. Ersetzen Sie PdfRgbColor und PdfBrush durch CSS-Farben.
  9. Ersetzen Sie die Zusammenführung der Seitenschleife durch PdfDocument.Merge()
  10. IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Vergleichen Sie die visuelle Ausgabe, um sicherzustellen, dass das Aussehen den Erwartungen entspricht
  • Überprüfen der Textdarstellung mit dem neuen HTML/CSS-Ansatz
  • Bildpositionierung mit CSS überprüfen
  • Testseitenumbrüche treten wie erwartet auf
  • Prüfen, ob die PDF-Sicherheitseinstellungen korrekt angewendet werden
  • Test auf allen Zielplattformen

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von XFINIUM.PDF zu IronPDF bietet mehrere entscheidende Vorteile:

HTML-basierte Inhaltserstellung: Webentwickler können ihre vorhandenen HTML- und CSS-Kenntnisse nutzen. Sie müssen keine koordinatenbasierten Zeichen-APIs erlernen oder Schrift- und Pinselobjekte verwalten.

Automatisches Layout: Textumbruch, Seitenumbruch und Layoutfluss erfolgen automatisch. Keine manuelle Berechnung von Elementpositionen oder Seitenumbrüchen.

Moderne CSS-Unterstützung: Vollständige CSS3-Unterstützung inklusive Flexbox- und Grid-Layouts. Responsive Designs werden direkt in PDF übersetzt.

Vereinfachte PDF-Operationen: Aufrufe einzelner Methoden für häufige Operationen wie PdfDocument.Merge() ersetzen komplexe Seiteniterationsschleifen.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates von IronPDF die Kompatibilität mit aktuellen und zukünftigen .NET Versionen.

Umfangreiche Dokumentation: Große Community mit umfassender Dokumentation, Tutorials und Supportressourcen im Vergleich zum kleineren Ökosystem von XFINIUM.PDF.

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