VIDEOS

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Aktualisiert:19. Juli 2026

XFINIUM.PDF ist eine kommerzielle, plattformübergreifende PDF-Bibliothek, entwickelt von O2 Solutions, die Werkzeuge zur Erstellung und Bearbeitung von PDFs programmatisch in C# anbietet. Es gibt zwei Editionen — Generator (PDF-Erstellung und -Bearbeitung) und Viewer (Generator-Funktionen plus Rendering/Anzeige). Die Bibliothek wird auf NuGet als Xfinium.Pdf.NetStandard und Xfinium.Pdf.NetCore vertrieben. Sein koordinatenbasiertes Grafikprogrammiermodell kann Reibung für Teams schaffen, die dokumentenintensive Anwendungen entwickeln, da die meisten Layoutarbeiten das manuelle Positionieren von Elementen mit Pixelkoordinaten umfassen.

Diese Anleitung bietet einen Migrationspfad von XFINIUM.PDF zu IronPDF, mit Schritt-für-Schritt-Anleitungen, Codevergleichen und praktischen Beispielen for .NET-Entwickler, die diese Umstellung bewerten.

Warum von XFINIUM.PDF migrieren

XFINIUM.PDF ist eine Low-Level-PDF-Bibliothek, die auf koordinatenbasierte Grafikeprogrammierung setzt, was bedeutet, dass Entwickler die meisten Elemente direkt auf der Seite positionieren. Häufige Gründe, warum Entwicklungsteams eine Migration in Betracht ziehen:

Kein nativer HTML-Motor: XFINIUM.PDF verfügt nicht über einen integrierten HTML-zu-PDF-Konverter. Der Anbieter liefert einen Beispiel-XHTML-Walker, der einen begrenzten Tag-Satz (p, font, b, i, u, ul, li) unterstützt und weder CSS parst noch JavaScript ausführt, was möglicherweise nicht ausreicht für Projekte, die vollständige HTML-zu-PDF-Fähigkeiten erfordern.

Koordinatenbasierte API: Manuelles Positionieren mit Pixelkoordinaten wie DrawString("text", font, brush, 50, 100) ist für die meisten Platzierungen von Elementen erforderlich.

Manuelle Schriftartverwaltung: Schriftobjekte 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 werden durch programmatische Methodenaufrufe gehandhabt.

Kein JavaScript Rendering: Nur statischer Inhalt. XFINIUM.PDF rendert keine dynamischen Webinhalte und führt kein JavaScript aus.

Komplexes Textlayout: Manuelle Textmessung und Umbruchberechnungen sind in der Regel für alles erforderlich, was über einfache einzeilige Texte hinausgeht.

Kleinere Gemeinschaft: Weniger von der Gemeinschaft bereitgestellte Beispiele und Tutorials im Vergleich zu Mainstream-Lösungen, was es neuen Benutzern erschweren kann, den Einstieg zu finden.

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	Kein nativer Motor; Nur-Beispiel-HTML-Konverter (beschränkte Tags, kein CSS/JS)	Volle HTML-zu-PDF-Konvertierung mit Chromium (CSS3 + JavaScript)
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	Nein	Vollständig CSS3
JavaScript	Nein	Vollständiger ES2024
Flexbox/Grid	Nein	Ja
Automatisches Layout	Nein	Ja
Automatische Seitenumbrüche	Nein	Ja
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

Entfernen Sie XFINIUM.PDF (die tatsächlichen NuGet-IDs sind plattformspezifisch):

# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf.NetStandard
# or: dotnet remove package Xfinium.Pdf.NetCore

# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf.NetStandard
# or: dotnet remove package Xfinium.Pdf.NetCore

SHELL

IronPDF installieren:

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie XFINIUM.PDF-Namespaces durch den IronPDF-Namespace:

// 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.NetStandard (or .NetCore)
// XFINIUM.PDF has no native HTML-to-PDF engine. Flow content accepts
// styled text, headings, tables and images - not HTML. The vendor sample
// converter parses limited XHTML (p, font, b, i, u, ul, li) into
// PdfFormattedContent; full CSS/JS rendering is not supported.
using Xfinium.Pdf;
using Xfinium.Pdf.FlowDocument;
using Xfinium.Pdf.Graphics;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        flowDocument.AddContent(new PdfFlowHeadingContent(
            "Hello World",
            new PdfStandardFont(PdfStandardFontFace.HelveticaBold, 18)));

        flowDocument.AddContent(new PdfFlowTextContent(
            "This is a PDF generated from text content (not HTML).",
            new PdfStandardFont(PdfStandardFontFace.Helvetica, 12)));

        using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
        {
            flowDocument.Save(fs);
        }
    }
}

// NuGet: Install-Package Xfinium.Pdf.NetStandard (or .NetCore)
// XFINIUM.PDF has no native HTML-to-PDF engine. Flow content accepts
// styled text, headings, tables and images - not HTML. The vendor sample
// converter parses limited XHTML (p, font, b, i, u, ul, li) into
// PdfFormattedContent; full CSS/JS rendering is not supported.
using Xfinium.Pdf;
using Xfinium.Pdf.FlowDocument;
using Xfinium.Pdf.Graphics;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        flowDocument.AddContent(new PdfFlowHeadingContent(
            "Hello World",
            new PdfStandardFont(PdfStandardFontFace.HelveticaBold, 18)));

        flowDocument.AddContent(new PdfFlowTextContent(
            "This is a PDF generated from text content (not HTML).",
            new PdfStandardFont(PdfStandardFontFace.Helvetica, 12)));

        using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
        {
            flowDocument.Save(fs);
        }
    }
}

Imports Xfinium.Pdf
Imports Xfinium.Pdf.FlowDocument
Imports Xfinium.Pdf.Graphics
Imports System.IO

Module Program
    Sub Main()
        Dim flowDocument As New PdfFlowDocument()

        flowDocument.AddContent(New PdfFlowHeadingContent(
            "Hello World",
            New PdfStandardFont(PdfStandardFontFace.HelveticaBold, 18)))

        flowDocument.AddContent(New PdfFlowTextContent(
            "This is a PDF generated from text content (not HTML).",
            New PdfStandardFont(PdfStandardFontFace.Helvetica, 12)))

        Using fs As New FileStream("output.pdf", FileMode.Create)
            flowDocument.Save(fs)
        End Using
    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 PdfFlowDocument, das Instanziieren von PdfStandardFont-Objekten für jeden Stil, das Bauen jedes Inhaltsstücks als PdfFlowHeadingContent oder PdfFlowTextContent, das Hinzufügen zu dem Flussdokument und das Speichern über ein FileStream. Die Flussdokument-API akzeptiert typisierte Inhaltsobjekte, keine HTML-Markups.IronPDF vereinfacht dies auf drei Zeilen: Erstellen Sie einen Renderer, rendern Sie HTML und speichern Sie.

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.NetStandard (or .NetCore)
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.NetStandard (or .NetCore)
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 stellt eine einzelne PdfDocument.Merge()-Methode bereit, die alle 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.NetStandard (or .NetCore)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
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(new PdfRgbColor(0, 0, 0));

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

        using (FileStream imageStream = File.OpenRead("image.jpg"))
        {
            PdfJpegImage image = new PdfJpegImage(imageStream);
            page.Graphics.DrawImage(image, 50, 100, 200, 150);
        }

        document.Save("output.pdf");
    }
}

// NuGet: Install-Package Xfinium.Pdf.NetStandard (or .NetCore)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
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(new PdfRgbColor(0, 0, 0));

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

        using (FileStream imageStream = File.OpenRead("image.jpg"))
        {
            PdfJpegImage image = new PdfJpegImage(imageStream);
            page.Graphics.DrawImage(image, 50, 100, 200, 150);
        }

        document.Save("output.pdf");
    }
}

Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
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(New PdfRgbColor(0, 0, 0))

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

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

        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 Schrift- und Pinselobjekten, das Zeichnen von Text an spezifischen 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` auf `<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()`
Anbieterbeispiel-HTML-Konverter	`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 von PdfStandardFont- oder PdfUnicodeTrueTypeFont-Objekten für jede Schriftart.

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 von PdfRgbColor- und PdfBrush-Objekten 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: Öffnen von Dateistreams, Erstellen von PdfJpegImage-Objekten, Zeichnen an Koordinaten, Schließen von Streams.

Lösung: Verwenden von HTML-<img>-Tags 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. Schrift- und Farbobjekte identifizieren (PdfStandardFont, PdfRgbColor, PdfBrush). Zusammengeführte PDF-Workflows mithilfe von PdfFixedDocument.Pages.Add() abbilden.

Aufgaben der Code-Aktualisierung

Xfinium.Pdf NuGet-Paket entfernen 2.IronPDF NuGet-Paket installieren
Aktualisieren der Namespace-Importe von Xfinium.Pdf zu IronPdf
Konvertieren von DrawString()-Aufrufen zu HTML-Text-Elementen
Konvertieren von DrawImage()-Aufrufen zu HTML-<img>-Tags
Konvertieren von DrawRectangle() und DrawLine() zu CSS-Rändern
Ersetzen von PdfStandardFont durch CSS font-family
Ersetzen von PdfRgbColor und PdfBrush durch CSS-Farben
Ersetzen von Seitenschleifen-Merging durch PdfDocument.Merge()
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: Einfache Methodenaufrufe für häufige Operationen wie PdfDocument.Merge() ersetzen komplexe Iterationsschleifen.

Aktive Entwicklung: IronPDFs regelmäßige Updates halten mit aktuellen .NET-Versionen und C#-Sprachversionen Schritt.

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

Hinweis:Xfinium PDF ist eine eingetragene Marke des jeweiligen Eigentümers. Diese Seite ist nicht mit, von XFINIUM Software unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

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 ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Warum von XFINIUM.PDF migrieren

Das Kernproblem: Grafik-API vs. HTML

IronPDF vs. XFINIUM.PDF: Funktionsvergleich

Schnellstart: XFINIUM.PDF zu IronPDF Migration

Schritt 1: Ersetzen des NuGet-Pakets

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Mehrere PDFs zusammenführen

Erstellen von PDFs mit Text und Bildern

XFINIUM.PDF API zu IronPDF Mapping-Referenz

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: Koordinatenbasiertes Layout

Ausgabe 2: Font-Objekt-Verwaltung

Ausgabe 3: Farbverarbeitung

Ausgabe 4: Manuelle Seitenumbrüche

Ausgabe 5: Laden von Bildern

XFINIUM.PDF Migration Checkliste

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Die wichtigsten Vorteile der Migration zu IronPDF

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Iron-Support-Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Warum von XFINIUM.PDF migrieren

Das Kernproblem: Grafik-API vs. HTML

IronPDF vs. XFINIUM.PDF: Funktionsvergleich

Schnellstart: XFINIUM.PDF zu IronPDF Migration

Schritt 1: Ersetzen des NuGet-Pakets

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Mehrere PDFs zusammenführen

Erstellen von PDFs mit Text und Bildern

XFINIUM.PDF API zu IronPDF Mapping-Referenz

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: Koordinatenbasiertes Layout

Ausgabe 2: Font-Objekt-Verwaltung

Ausgabe 3: Farbverarbeitung

Ausgabe 4: Manuelle Seitenumbrüche

Ausgabe 5: Laden von Bildern

XFINIUM.PDF Migration Checkliste

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Die wichtigsten Vorteile der Migration zu IronPDF

Verwandte Artikel

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

Wie man XML in PDF mit C# konvertiert

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Thank You

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Möchten Sie IronSuite KOSTENLOS in einem Live-Projekt einsetzen?

DLL-Download

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Von Millionen von Ingenieur*innen weltweit vertraut

Iron-Support-Team