Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migracja z xfinium.pdf do IronPDF
PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z XFINIUM.PDF do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

XFINIUM.PDF to wieloplatformowa biblioteka PDF, która oferuje kompleksowe narzędzia do programowego tworzenia i edycji plików PDF w języku C#. Chociaż biblioteka oferuje dwie edycje — Generator i Viewer — jej oparcie na programowaniu graficznym opartym na współrzędnych stwarza poważne wyzwania dla zespołów programistów tworzących aplikacje zawierające duże ilości dokumentów. Każdy element musi być ręcznie pozycjonowany przy użyciu współrzędnych pikselowych, co sprawia, że proste dokumenty stają się skomplikowanymi ćwiczeniami z rysowania.

Niniejszy przewodnik zawiera kompletną ścieżkę migracji z XFINIUM.PDF do IronPDF, wraz z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla profesjonalnych programistów .NET rozważających tę zmianę.

Dlaczego warto przejść z XFINIUM.PDF

XFINIUM.PDF to biblioteka PDF niskiego poziomu, która opiera się na programowaniu graficznym opartym na współrzędnych, zmuszając programistów do ręcznego pozycjonowania każdego elementu na stronie. Takie podejście staje się koszmarem konserwacyjnym w miarę zmiany wymagań. Główne powody, dla których zespoły programistów rozważają migrację, to:

Brak obsługi HTML: XFINIUM.PDF nie może bezpośrednio konwertować HTML/CSS do formatu PDF. Skupia się na programowym tworzeniu plików PDF przy użyciu nisko poziomowych elementów rysunkowych, co może nie wystarczyć w przypadku projektów wymagających rozbudowanych możliwości konwersji HTML do PDF.

API oparte na współrzędnych: Dla każdego elementu na stronie wymagane jest ręczne pozycjonowanie za pomocą współrzędnych pikselowych, takich jak DrawString("text", font, brush, 50, 100).

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

Brak stylów CSS: Brak obsługi nowoczesnych stylów internetowych. Kolory, czcionki i układy muszą być obsługiwane ręcznie poprzez programowe wywołania metod.

Brak renderowania JavaScript: Tylko treści statyczne. XFINIUM.PDF nie może renderować dynamicznej zawartości internetowej ani wykonywać kodu JavaScript.

Złożony układ tekstu: W przypadku treści wykraczających poza prosty tekst jednowierszowy konieczne jest ręczne mierzenie tekstu i obliczanie zawijania.

Ograniczone zasoby społecznościowe: W porównaniu z popularnymi rozwiązaniami brakuje zasobów udostępnianych przez społeczność, takich jak przykłady i samouczki, 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
$vbLabelText   $csharpLabel

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)
$vbLabelText   $csharpLabel

IronPDFa XFINIUM.PDF: Porównanie funkcji

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

Funkcja XFINIUM.PDF IronPDF
HTML do PDF Ograniczona obsługa HTML, skupia się na programowym tworzeniu plików PDF Pełna konwersja HTML do PDF z kompleksową obsługą
Społeczność i wsparcie Mniejsza społeczność, mniej dostępnych zasobów online Duża społeczność z obszerną dokumentacją i samouczkami
Licencja Reklama z licencjonowaniem dla programistów Komercjalne
Obsługa wielu platform Silne możliwości wieloplatformowe Obsługuje również operacje międzyplatformowe
Obsługa CSS Nie Pełny CSS3
JavaScript Nie Pełna wersja ES2024
Flexbox/Grid Nie Tak
Automatyczny układ Nie Tak
Automatyczne podziały stron Nie Tak
Ręczne pozycjonowanie Wymagane Opcjonalnie (pozycjonowanie CSS)
Krzywa uczenia się Wysoki (układ współrzędnych) Niski (HTML/CSS)
Rozbudowanie kodu Bardzo wysoka Low

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:

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

Zainstaluj IronPDF:

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

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

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"
$vbLabelText   $csharpLabel

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

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");
    }
}
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 wymaga utworzenia obiektu PdfFixedDocument, PdfFlowDocument, PdfFlowContent, wywołania AppendHtml(), dodania treści do dokumentu przepływowego, renderowania do dokumentu stałego i wreszcie zapisania.IronPDFupraszcza to do trzech kroków: utwórz renderer, wyrenderuj 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
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

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");
    }
}
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 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.IronPDFudostępnia jedną metodę PdfDocument.Merge(), która wewnętrznie radzi sobie ze wszystkimi złożonymi zadaniami.

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

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");
    }
}
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 wymaga utworzenia dokumentu, dodania strony, utworzenia obiektów czcionek i pędzli, narysowania tekstu w określonych współrzędnych, otwarcia strumienia obrazu, utworzenia PdfJpegImage, narysowania obrazu w współrzędnych o określonych wymiarach, zamknięcia strumienia i zapisania.IronPDFwykorzystuje 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 doIronPDF– dokumentacja API dla mapowania

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

XFINIUM.PDF IronPDF
PdfFixedDocument ChromePdfRenderer
PdfPage Automatyczne
page.Graphics.DrawString() Elementy tekstowe HTML
page.Graphics.DrawImage() <img> tag
page.Graphics.DrawLine() CSS border lub <hr>
page.Graphics.DrawRectangle() CSS border na <div>
PdfStandardFont CSS font-family
PdfRgbColor CSS color
PdfBrush Właściwości CSS
PdfJpegImage <img> tag z base64
document.Save(stream) pdf.SaveAs() lub pdf.BinaryData
PdfFlowDocument RenderHtmlAsPdf()
PdfFlowContent.AppendHtml() RenderHtmlAsPdf()

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

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

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

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:IronPDFobsługuje automatyczne podziały stron. Aby uzyskać precyzyjną kontrolę, użyj CSS:

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

Problem 5: Ładowanie obrazów

XFINIUM.PDF: Otwieranie strumieni plików, tworzenie obiektów PdfJpegImage, rysowanie w określonych współrzędnych, zamykanie strumieni.

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

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

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

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

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

Zadania związane z aktualizacją kodu

  1. Usuń pakiet NuGet Xfinium.PDF
  2. Zainstaluj pakiet IronPdf NuGet
  3. Zaktualizuj importy przestrzeni nazw z Xfinium.Pdf na IronPdf
  4. Zamień wywołania DrawString() na elementy tekstowe HTML
  5. Zamień wywołania DrawImage() na tagi HTML <img>
  6. Zamień DrawRectangle() i DrawLine() na obramowania CSS
  7. Zastąp PdfStandardFont na CSS font-family
  8. Zastąp PdfRgbColor i PdfBrush kolorami CSS
  9. Zastąp scalanie pętli stron przez PdfDocument.Merge()
  10. Dodaj inicjalizację licencjiIronPDFpodczas 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 naIronPDFzapewnia 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 na plikach PDF: pojedyncze wywołania metod dla typowych operacji, takich jak PdfDocument.Merge(), zastępują złożone pętle iteracji stron.

Aktywny rozwój: W miarę jak do 2026 r. wzrośnie popularność .NET 10 i C# 14, regularne aktualizacjeIronPDFzapewnią zgodność z obecnymi i przyszłymi wersjami .NET.

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

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie