XFINIUM.PDF to komercyjna, wieloplatformowa biblioteka PDF, rozwijana przez O2 Solutions, która oferuje narzędzia do tworzenia i edytowania PDF-ów programatycznie w C#. Oferowane są dwie edycje — Generator (generowanie i edycja PDF) oraz Viewer (funkcje Generatora plus renderowanie/wyświetlanie). Biblioteka jest dystrybuowana na NuGet jako Xfinium.Pdf.NetStandard oraz Xfinium.Pdf.NetCore. Jego model programowania graficznego oparty na koordynatach może stwarzać trudności zespołom budującym aplikacje z dużą zawartością dokumentów, ponieważ większość prac układowych wymaga ręcznego pozycjonowania elementów przy użyciu współrzędnych pikselowych.

Ten przewodnik oferuje ścieżkę migracji z XFINIUM.PDF do IronPDF, z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla deweloperów .NET oceniających tę zmianę.

Dlaczego warto przejść z XFINIUM.PDF

XFINIUM.PDF to niskopoziomowa biblioteka PDF, która opiera się na graficznym programowaniu opartym na współrzędnych, co oznacza, że programiści pozycjonują większość elementów na stronie bezpośrednio. Powszechne powody, dla których zespoły programistyczne rozważają migrację, obejmują:

Brak natywnego silnika HTML: XFINIUM.PDF nie posiada wbudowanego konwertera HTML-to-PDF. Dostawca dostarcza przykładowy program do przetwarzania XHTML, który obsługuje ograniczony zestaw tagów (p, font, b, i, u, ul, li) i nie analizuje CSS ani nie wykonuje JavaScript, co może nie wystarczać dla projektów wymagających pełnych możliwości konwersji HTML do PDF.

API oparte na współrzędnych: Ręczne ustawienie z współrzędnymi pikselowymi jak DrawString("text", font, brush, 50, 100) jest wymagane do większości rozmieszczania elementów.

Ręczne zarządzanie czcionkami: Obiekty czcionkowe muszą być tworzone i zarządzane jawnie przy użyciu klas takich jak PdfStandardFont oraz PdfBrush.

Brak stylów CSS: Brak obsługi nowoczesnych stylów internetowych. Kolory, czcionki i układy są obsługiwane za pomocą wywołań metod programatycznych.

Brak renderowania JavaScript: Tylko treści statyczne. XFINIUM.PDF nie renderuje dynamicznych treści webowych ani nie wykonuje JavaScript.

Złożone układy tekstu: Ręczne pomiary i obliczenia zawijania tekstu są zazwyczaj wymagane dla elementów bardziej złożonych niż proste jedno-liniowe teksty.

Mniejsza społeczność: Mniej przykładów i tutoriali opracowanych przez społeczność w porównaniu do rozwiązań mainstreamowych, co może utrudniać nowym użytkownikom rozpoczęcie pracy.

Główny problem: API graficzne a HTML

XFINIUM.PDF zmusza do myślenia jak programista graficzny, a nie projektant dokumentów:

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

' 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

IronPDF wykorzystuje znane 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)

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

##IronPDF a XFINIUM.PDF: Porównanie funkcji

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Szybki start: Migracja z XFINIUM.PDF do IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Zastąp pakiet NuGet

Usuń XFINIUM.PDF (rzeczywiste ID NuGet są specyficzne dla platformy):

# 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

Zainstaluj IronPDF:

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

Krok 2: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazw XFINIUM.PDF przestrzenią nazw IronPDF:

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

Imports IronPdf

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Przykłady migracji kodu

Konwersja HTML do PDF

Najbardziej podstawowa operacja ujawnia różnicę w złożoności między tymi bibliotekami .NET do obsługi plików PDF.

Podejście XFINIUM.PDF:

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

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

Podejście IronPDF:

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

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main()
        Dim renderer As 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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main()
        Dim renderer As 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 Module

XFINIUM.PDF wymaga utworzenia PdfFlowDocument, tworzenia obiektów PdfStandardFont dla każdego stylu, budowania każdego fragmentu treści jako PdfFlowHeadingContent lub PdfFlowTextContent, dodawania ich do dokumentu przepływowego i zapisywania za pomocą FileStream. API dokumentów przepływu przyjmuje typowane obiekty treści, a nie znacznik HTML.IronPDF upraszcza to do trzech linii: utwórz renderer, renderuj HTML i zapisz.

W przypadku zaawansowanych scenariuszy konwersji HTML do PDF zapoznaj się z przewodnikiem po konwersji HTML do PDF.

Łączenie wielu plików PDF

Łączenie plików PDF wyraźnie pokazuje różnice w złożoności API.

Podejście XFINIUM.PDF:

// 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();
    }
}

Podejście IronPDF:

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

' NuGet: Install-Package IronPdf
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

' NuGet: Install-Package IronPdf
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

XFINIUM.PDF wymaga utworzenia dokumentu wyjściowego, otwarcia strumieni plików, załadowania każdego dokumentu, ręcznego przeglądania stron i dodawania ich pojedynczo, zapisania, a następnie zamknięcia strumieni.IronPDF udostępnia jedną metodę PdfDocument.Merge(), która obsługuje całą złożoność wewnętrznie.

Zapoznaj się z dokumentacją dotyczącą łączenia plików PDF, aby poznać dodatkowe opcje łączenia.

Tworzenie plików PDF z tekstem i obrazami

Dokumenty o mieszanej treści pokazują fundamentalną różnicę paradygmatyczną.

Podejście XFINIUM.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");
    }
}

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

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

Podejście IronPDF:

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

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

Module Program
    Sub Main()
        Dim renderer As 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 Module

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

Module Program
    Sub Main()
        Dim renderer As 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 Module

XFINIUM.PDF wymaga stworzenia dokumentu, dodania strony, stworzenia obiektów czcionki i pędzla, rysowania tekstu w określonych współrzędnych, otworzenia strumienia obrazu, stworzenia PdfJpegImage, rysowania obrazu w współrzędnych z wymiarami, zamknięcia strumienia i zapisania.IronPDF wykorzystuje standardowy kod HTML z osadzonymi obrazami w formacie base64 — to samo podejście, z którego na co dzień korzystają programiści stron internetowych.

XFINIUM.PDF API do IronPDF– dokumentacja API dla mapowania

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Układ oparty na współrzędnych

XFINIUM.PDF: Wszystko wymaga dokładnych współrzędnych X,Y z ręcznym pozycjonowaniem.

Rozwiązanie: Zastosuj układ płynny HTML/CSS. W razie potrzeby do pozycjonowania absolutnego użyj CSS:

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

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

Problem 2: Zarządzanie obiektami czcionek

XFINIUM.PDF: Utwórz obiekty PdfStandardFont lub PdfUnicodeTrueTypeFont dla każdej czcionki.

Rozwiązanie: Użyj właściwości CSS font-family — czcionki są obsługiwane automatycznie:

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

Problem 3: Obsługa kolorów

XFINIUM.PDF: Utwórz obiekty PdfRgbColor i PdfBrush dla kolorów.

Rozwiązanie: Użyj standardowych kolorów CSS:

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

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

Problem 4: Ręczne podziały stron

XFINIUM.PDF: Śledź pozycję Y i ręcznie twórz nowe strony, gdy zawartość się przepełnia.

**Rozwiązanie:**IronPDF obsługuje automatyczne podziały stron. Aby uzyskać precyzyjną kontrolę, użyj CSS:

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

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

Problem 5: Ładowanie obrazów

XFINIUM.PDF: Otwórz strumienie plików, utwórz obiekty PdfJpegImage, rysuj w współrzędnych, zamknij strumienie.

Rozwiązanie: Użyj tagów HTML <img> z ścieżkami do plików lub danymi base64:

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

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

Lista kontrolna migracji XFINIUM.PDF

Zadania przed migracją

Przeprowadź audyt kodu źródłowego, aby zidentyfikować wszystkie przypadki użycia XFINIUM.PDF:

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

Należy uwzględnić układy oparte na współrzędnych i odnotować wszystkie wartości pozycjonowania X,Y. Zidentyfikuj obiekty czcionki i kolorów (PdfStandardFont, PdfRgbColor, PdfBrush). Mapuj scalone przepływy PDF za pomocą PdfFixedDocument.Pages.Add().

Zadania związane z aktualizacją kodu

1. Usuń pakiet NuGet Xfinium.PDF
2. Zainstaluj pakiet NuGet IronPDF
3. Zaktualizuj importy przestrzeni nazw z Xfinium.Pdf na IronPdf
4. Przekształć wywołania DrawString() na elementy tekstowe HTML
5. Przekształć wywołania DrawImage() na tagi HTML <img>
6. Przekształć DrawRectangle() i DrawLine() na obramowania CSS
7. Zamień PdfStandardFont z CSS font-family
8. Zamień PdfRgbColor i PdfBrush z kolorami CSS
9. Zamień scalanie pętli stron z PdfDocument.Merge()
10. Dodaj inicjalizację licencji IronPDF podczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

• Porównaj wygląd końcowy, aby upewnić się, że odpowiada on oczekiwaniom
• Sprawdź renderowanie tekstu przy użyciu nowego podejścia HTML/CSS
• Sprawdź pozycjonowanie obrazów za pomocą CSS
• Sprawdzono, czy podziały stron zachodzą zgodnie z oczekiwaniami
• Sprawdź, czy ustawienia zabezpieczeń pliku PDF zostały poprawnie zastosowane
• Przetestuj na wszystkich platformach docelowych

Kluczowe korzyści z migracji do IronPDF

Przejście z XFINIUM.PDF na IronPDF zapewnia kilka kluczowych korzyści:

Tworzenie treści opartych na HTML: Programiści stron internetowych mogą wykorzystać swoje dotychczasowe umiejętności w zakresie HTML i CSS. Nie ma potrzeby uczenia się interfejsów API rysowania opartych na współrzędnych ani zarządzania obiektami czcionek i pędzli.

Automatyczny układ: zawijanie tekstu, paginacja i układ przepływu odbywają się automatycznie. Nie należy ręcznie obliczać pozycji elementów ani podziałów stron.

Obsługa nowoczesnego CSS: Pełna obsługa CSS3, w tym układy Flexbox i Grid. Responsywne projekty są bezpośrednio konwertowane do formatu PDF.

Uproszczone operacje PDF: Wywołania jedną metodą dla typowych operacji, takich jak PdfDocument.Merge(), zastępują złożone pętle iteracji stron.

Aktywny rozwój: Regularne aktualizacje IronPDF nadążają za bieżącymi wersjami .NET i wydaniami języka C#.

Obszerna dokumentacja: Duża społeczność z obszerną dokumentacją, samouczkami i zasobami wsparcia w porównaniu z mniejszym ekosystemem XFINIUM.PDF.