PORóWNANIE

FO.NET vs IronPDF: Przewodnik po porównaniu technicznym

Zaktualizowano:

Kiedy programiści .NET szukają rozwiązań do generowania plików PDF, FO.NET wyróżnia się jako specjalistyczne narzędzie do konwersji dokumentów XSL-FO do formatu PDF. Jednak zależność od przestarzałego języka XSL-FO, brak obsługi HTML/CSS oraz zaprzestanie dalszego rozwoju sprawiają, że wiele zespołów rozważa alternatywne rozwiązania.IronPDFoferuje nowoczesne rozwiązanie wykorzystujące standardy internetowe HTML/CSS, które są już znane większości programistów, wyposażone w silnik renderujący Chromium i regularne comiesięczne aktualizacje.

W niniejszym porównaniu przeanalizowano obie biblioteki pod kątem istotnych aspektów technicznych, aby pomóc profesjonalnym programistom i architektom w podejmowaniu świadomych decyzji dotyczących ich potrzeb w zakresie obsługi plików PDF w środowisku .NET.

Zrozumienie FO.NET

FO.NET (znany również jako FoNet) to biblioteka open source przeznaczona do konwersji dokumentów XSL Formatting Object (XSL-FO) do formatu PDF przy użyciu języka C#. Biblioteka działa na licencji Apache 2.0 i bezpośrednio przekształca język XSL-FO do formatu PDF.

FO.NET używa FonetDriver jako swojej głównej klasy, przy czym metoda fabryki Make() tworzy instancje sterowników, a metody Render() przetwarzają strumienie wejściowe XSL-FO, aby generować strumienie wyjściowe PDF. Konfiguracja odbywa się w samym znaczniku XSL-FO za pomocą elementów takich jak fo:simple-page-master, fo:layout-master-set i atrybutów formatowania dla marginesów, rozmiarów stron i czcionek.

Istotnym ograniczeniem jest to, że FO.NET wymaga znajomości XSL-FO — języka opartego na XML, który jest specyfikacją W3C z 2001 r. i nie był aktualizowany od 2006 r. Biblioteka nie obsługuje HTML ani CSS i nie może bezpośrednio renderować stron internetowych. XSL-FO jest powszechnie uważane za przestarzałe w dzisiejszej branży technologicznej, a mniej niż 1% programistów posiada w nim doświadczenie w porównaniu z ponad 98%, którzy znają HTML/CSS.

Oryginalne repozytorium CodePlex nie istnieje, a rozgałęzienia na GitHubie nie są już aktywnie utrzymywane. FO.NET ma wewnętrzne zależności od System.Drawing, które uniemożliwiają jego działanie w systemach Linux/macOS, ograniczając wdrożenie wyłącznie do systemu Windows.

Zrozumienie IronPDF

IronPDF to biblioteka PDF dla platformy .NET, która wykorzystuje HTML/CSS do stylizacji i układu dokumentów, stosując standardy internetowe powszechnie stosowane w programowaniu. Biblioteka wykorzystuje silnik renderujący Chromium, zapewniający pełną obsługę CSS3, w tym układy Flexbox i Grid, a także wykonywanie kodu JavaScript.

IronPDF używa ChromePdfRenderer jako swojej głównej klasy renderującej, przy czym RenderingOptions dostarcza programatyczną konfigurację dla rozmiaru strony, marginesów, nagłówków, stopki i innych ustawień PDF. Biblioteka obsługuje bezpośrednie renderowanie URL, renderowanie ciągów HTML i renderowanie plików HTML, co daje obiekty PdfDocument, które można zapisać, scalić, zabezpieczyć lub dalej manipulować.

IronPDF jest aktywnie rozwijany, co miesiąc pojawiają się nowe wersje, obsługuje prawdziwe wdrażanie na wielu platformach (Windows, Linux, macOS) oraz zapewnia obszerną dokumentację i samouczki.

Porównanie architektury i technologii

Podstawowa różnica między tymi bibliotekami .NET do obsługi plików PDF polega na formacie danych wejściowych i technologii, na której są oparte.

Aspekt FO.NET IronPDF
Format danych wejściowych XSL-FO (przestarzały XML) HTML/CSS (nowoczesne standardy internetowe)
Krzywa uczenia się Steep (doświadczenie w zakresie XSL-FO) Łagodny (znajomość HTML/CSS)
Konserwacja Porzucony Aktywnie aktualizowane co miesiąc
Obsługa platform Tylko dla systemu Windows Prawdziwa wielopłatformowość
Obsługa CSS None Pełna obsługa CSS3 (Flexbox, Grid)
JavaScript None Pełna obsługaJavaScript
Renderowanie adresów URL Nieobsługiwane Wbudowane
Nowoczesne funkcje Ograniczone Nagłówki, stopki, znaki wodne, zabezpieczenia
Dokumentacja Nieaktualne Kompleksowe samouczki

FO.NET został zaprojektowany w czasie, gdy oczekiwano, że XSL-FO stanie się standardem formatowania dokumentów. Tak się nie stało — HTML/CSS stały się uniwersalnym formatem dokumentów. Większość zasobów dotyczących XSL-FO pochodzi z lat 2005–2010, co sprawia, że coraz trudniej jest znaleźć aktualne informacje lub wsparcie społeczności.

Porównanie kodu: typowe operacje na plikach PDF

Konwersja HTML do PDF

Najbardziej podstawowa operacja pokazuje różnicę modelową między podejściami XSL-FO i HTML.

FO.NET:

// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;
using System.Xml;

class Program
{
    static void Main()
    {
        // FoNet requires XSL-FO format, not HTML
        // First convert HTML to XSL-FO (manual process)
        string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
            <fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
                <fo:layout-master-set>
                    <fo:simple-page-master master-name='page'>
                        <fo:region-body/>
                    </fo:simple-page-master>
                </fo:layout-master-set>
                <fo:page-sequence master-reference='page'>
                    <fo:flow flow-name='xsl-region-body'>
                        <fo:block>Hello World</fo:block>
                    </fo:flow>
                </fo:page-sequence>
            </fo:root>";

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("output.pdf", FileMode.Create));
    }
}
// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;
using System.Xml;

class Program
{
    static void Main()
    {
        // FoNet requires XSL-FO format, not HTML
        // First convert HTML to XSL-FO (manual process)
        string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
            <fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
                <fo:layout-master-set>
                    <fo:simple-page-master master-name='page'>
                        <fo:region-body/>
                    </fo:simple-page-master>
                </fo:layout-master-set>
                <fo:page-sequence master-reference='page'>
                    <fo:flow flow-name='xsl-region-body'>
                        <fo:block>Hello World</fo:block>
                    </fo:flow>
                </fo:page-sequence>
            </fo:root>";

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("output.pdf", FileMode.Create));
    }
}
Imports Fonet
Imports Fonet.Render.Pdf
Imports System.IO
Imports System.Xml

Module Program
    Sub Main()
        ' FoNet requires XSL-FO format, not HTML
        ' First convert HTML to XSL-FO (manual process)
        Dim xslFo As String = "<?xml version='1.0' encoding='utf-8'?>" & _
            "<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>" & _
                "<fo:layout-master-set>" & _
                    "<fo:simple-page-master master-name='page'>" & _
                        "<fo:region-body/>" & _
                    "</fo:simple-page-master>" & _
                "</fo:layout-master-set>" & _
                "<fo:page-sequence master-reference='page'>" & _
                    "<fo:flow flow-name='xsl-region-body'>" & _
                        "<fo:block>Hello World</fo:block>" & _
                    "</fo:flow>" & _
                "</fo:page-sequence>" & _
            "</fo:root>"

        Dim driver As FonetDriver = FonetDriver.Make()
        driver.Render(New StringReader(xslFo), 
                      New FileStream("output.pdf", FileMode.Create))
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is HTML content.</p>";
        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 = "<h1>Hello World</h1><p>This is HTML content.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Hello World</h1><p>This is HTML content.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Kontrast jest wyraźny. FO.NET wymaga rozwlekłego znacznikowania XSL-FO z deklaracjami przestrzeni nazw XML, elementami fo:root, fo:layout-master-set, fo:simple-page-master, fo:page-sequence, fo:flow i fo:block—wszystko to przed wygenerowaniem prostego tekstu "Hello World". W komentarzu do kodu wyraźnie zaznaczono: "FoNet wymaga formatu XSL-FO, a nie HTML".

IronPDF tworzy renderer, przekazuje standardowy kod HTML, renderuje do formatu PDF i zapisuje — cztery proste linijki kodu przy użyciu składni znanej programistom.

Aby uzyskać informacje na temat zaawansowanych opcji renderowania HTML, zapoznaj się z przewodnikiem dotyczącym konwersji HTML do PDF.

Konwersja adresów URL do formatu PDF

Konwersja stron internetowych do formatu PDF ujawnia poważną lukę w możliwościach.

FO.NET:

// NuGet: Install-Package Fonet
using Fonet;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // FoNet does not support URL rendering directly
        // Must manually download, convert HTML to XSL-FO, then render
        string url = "https://example.com";
        string html = new WebClient().DownloadString(url);

        // Manual conversion from HTML to XSL-FO required (complex)
        string xslFo = ConvertHtmlToXslFo(html); // Not built-in

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("webpage.pdf", FileMode.Create));
    }

    static string ConvertHtmlToXslFo(string html)
    {
        // Custom implementation required
        throw new System.NotImplementedException();
    }
}
// NuGet: Install-Package Fonet
using Fonet;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // FoNet does not support URL rendering directly
        // Must manually download, convert HTML to XSL-FO, then render
        string url = "https://example.com";
        string html = new WebClient().DownloadString(url);

        // Manual conversion from HTML to XSL-FO required (complex)
        string xslFo = ConvertHtmlToXslFo(html); // Not built-in

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("webpage.pdf", FileMode.Create));
    }

    static string ConvertHtmlToXslFo(string html)
    {
        // Custom implementation required
        throw new System.NotImplementedException();
    }
}
Imports Fonet
Imports System.IO
Imports System.Net

Class Program
    Shared Sub Main()
        ' FoNet does not support URL rendering directly
        ' Must manually download, convert HTML to XSL-FO, then render
        Dim url As String = "https://example.com"
        Dim html As String = New WebClient().DownloadString(url)

        ' Manual conversion from HTML to XSL-FO required (complex)
        Dim xslFo As String = ConvertHtmlToXslFo(html) ' Not built-in

        Dim driver As FonetDriver = FonetDriver.Make()
        driver.Render(New StringReader(xslFo), 
                      New FileStream("webpage.pdf", FileMode.Create))
    End Sub

    Shared Function ConvertHtmlToXslFo(html As String) As String
        ' Custom implementation required
        Throw New System.NotImplementedException()
    End Function
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

FO.NET wyraźnie nie obsługuje renderowania adresów URL. Komentarze w kodzie stwierdzają: "FoNet nie obsługuje bezpośrednio renderowania URL" i "Wymagana ręczna konwersja z HTML do XSL-FO (skomplikówane)." Metoda ConvertHtmlToXslFo() rzuca NotImplementedException, ponieważ ta konwersja nie jest wbudowana i wymagałaby niestandardowej implementacji.

IronPDF zapewnia natywną funkcjonalność RenderUrlAsPdf(), która obsługuje pobieranie URL, wykonywanie JavaScriptu i renderowanie w jednym wywołaniu metody—trzy linie kodu w porównaniu z złożonym, niezrealizowanym przepływem pracy.

Więcej informacji na temat renderowania adresów URL można znaleźć w dokumentacji funkcji URL to PDF.

Plik PDF z ustawieniami niestandardowymi

Konfiguracja wymiarów strony i marginesów pokazuje różnice w podejściu do konfiguracji.

FO.NET:

// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        // FoNet settings are configured in XSL-FO markup
        string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
            <fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
                <fo:layout-master-set>
                    <fo:simple-page-master master-name='A4' 
                        page-height='297mm' page-width='210mm'
                        margin-top='20mm' margin-bottom='20mm'
                        margin-left='25mm' margin-right='25mm'>
                        <fo:region-body/>
                    </fo:simple-page-master>
                </fo:layout-master-set>
                <fo:page-sequence master-reference='A4'>
                    <fo:flow flow-name='xsl-region-body'>
                        <fo:block font-size='14pt'>Custom PDF</fo:block>
                    </fo:flow>
                </fo:page-sequence>
            </fo:root>";

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("custom.pdf", FileMode.Create));
    }
}
// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        // FoNet settings are configured in XSL-FO markup
        string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
            <fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
                <fo:layout-master-set>
                    <fo:simple-page-master master-name='A4' 
                        page-height='297mm' page-width='210mm'
                        margin-top='20mm' margin-bottom='20mm'
                        margin-left='25mm' margin-right='25mm'>
                        <fo:region-body/>
                    </fo:simple-page-master>
                </fo:layout-master-set>
                <fo:page-sequence master-reference='A4'>
                    <fo:flow flow-name='xsl-region-body'>
                        <fo:block font-size='14pt'>Custom PDF</fo:block>
                    </fo:flow>
                </fo:page-sequence>
            </fo:root>";

        FonetDriver driver = FonetDriver.Make();
        driver.Render(new StringReader(xslFo), 
            new FileStream("custom.pdf", FileMode.Create));
    }
}
Imports Fonet
Imports Fonet.Render.Pdf
Imports System.IO

Class Program
    Shared Sub Main()
        ' FoNet settings are configured in XSL-FO markup
        Dim xslFo As String = "<?xml version='1.0' encoding='utf-8'?>" & _
            "<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>" & _
                "<fo:layout-master-set>" & _
                    "<fo:simple-page-master master-name='A4' " & _
                        "page-height='297mm' page-width='210mm' " & _
                        "margin-top='20mm' margin-bottom='20mm' " & _
                        "margin-left='25mm' margin-right='25mm'>" & _
                        "<fo:region-body/>" & _
                    "</fo:simple-page-master>" & _
                "</fo:layout-master-set>" & _
                "<fo:page-sequence master-reference='A4'>" & _
                    "<fo:flow flow-name='xsl-region-body'>" & _
                        "<fo:block font-size='14pt'>Custom PDF</fo:block>" & _
                    "</fo:flow>" & _
                "</fo:page-sequence>" & _
            "</fo:root>"

        Dim driver As FonetDriver = FonetDriver.Make()
        driver.Render(New StringReader(xslFo), 
            New FileStream("custom.pdf", FileMode.Create))
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 25;
        renderer.RenderingOptions.MarginRight = 25;

        string html = "<h1 style='font-size:14pt'>Custom PDF</h1>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 25;
        renderer.RenderingOptions.MarginRight = 25;

        string html = "<h1 style='font-size:14pt'>Custom PDF</h1>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Engines.Chrome

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 25
        renderer.RenderingOptions.MarginRight = 25

        Dim html As String = "<h1 style='font-size:14pt'>Custom PDF</h1>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Komentarz w kodzie FO.NET wyraźnie stwierdza: "Ustawienia FoNet są konfigurowane w znaczniku XSL-FO." Rozmiar strony, marginesy i formatowanie są osadzone w strukturze XML jako atrybuty na fo:simple-page-master. Oznacza to, że konfiguracja jest powiązana z treścią w rozbudowanym formacie XML.

IronPDF oddziela konfigurację od treści za pomocą programatycznych właściwości RenderingOptions. Ustawienia takie jak PaperSize, MarginTop, MarginBottom, MarginLeft i MarginRight są ustawiane na obiekcie renderującym, podczas gdy treść pozostaje czystym HTML.

Przewodnik po mapowaniu API

Dla programistów rozważających migrację do FO.NET lub porównujących możliwości, poniższe zestawienie przedstawia równoważne operacje:

Mapowanie klas podstawowych

FO.NET IronPDF
FonetDriver.Make() new ChromePdfRenderer()
driver.Render(inputStream, outputStream) renderer.RenderHtmlAsPdf(html)
driver.Render(inputFile, outputStream) renderer.RenderHtmlFileAsPdf(path)
driver.BaseDirectory RenderingOptions.BaseUrl
driver.OnError += handler Try/catch wokół renderowania

Mapowanie XSL-FO do RenderingOptions

Atrybut XSL-FO IronPDF RenderingOptions
page-width PaperSize
margin-top MarginTop
margin-bottom MarginBottom
margin-left MarginLeft
margin-right MarginRight
reference-orientation PaperOrientation

Mapowanie elementów XSL-FO na HTML

Element XSL-FO Odpowiednik HTML
<fo:root> <html>
<fo:layout-master-set> RegułaCSS @page
<fo:simple-page-master> CSS @page
<fo:page-sequence> <body> lub <div>
<fo:flow> <main> lub <div>
<fo:static-content> HtmlHeaderFooter
<fo:block> <p>, <div>, <h1>-<h6>
<fo:table> <table>
<fo:list-block> <ul>, <ol>
<fo:external-graphic> <img>
<fo:page-number/> {page} placeholder

Podsumowanie porównania funkcji

Funkcja FO.NET IronPDF
HTML do PDF ❌(wymaga ręcznej konwersji do formatu XSL-FO) ✅
URL do pliku PDF ❌(nieobsługiwane) ✅
XSL-FO do PDF ✅ Nie dotyczy
Obsługa CSS3 ❌ ✅(Flexbox, Grid)
JavaScript ❌ ✅
Nagłówki/stopki Treść statyczna XSL-FO Oparty na HTML
Numeracja stron fo:page-number {page} placeholder
Wielopłatformowe ❌(tylko Windows) ✅
Aktywna konserwacja ❌(porzucone) ✅(co miesiąc)

Kiedy zespoły rozważają przejście z FO.NET na IronPDF

Zespoły programistów rozważają przejście z FO.NET naIronPDFfor .NET z kilku powodów:

Technologia przestarzała: XSL-FO to specyfikacja W3C z 2001 r., która nie była aktualizowana od 2006 r. i jest powszechnie uważana za przestarzałą. Większość zasobów i dokumentacji pochodzi z lat 2005–2010, co sprawia, że coraz trudniej jest znaleźć aktualne informacje lub zatrudnić programistów posiadających doświadczenie w zakresie XSL-FO.

Stroma krzywa uczenia się: XSL-FO wymaga opanowania skomplikówanego znacznika XML z wyspecjalizowanymi obiektami formatowania (fo:block, fo:table, fo:page-sequence, itp.). Mniej niż 1% programistów zna XSL-FO, w porównaniu z ponad 98%, którzy znają HTML/CSS.

Brak obsługi HTML/CSS: FO.NET nie może renderować HTML ani CSS — wymaga ręcznej konwersji z HTML do znaczników XSL-FO, która nie jest wbudowana w bibliotekę. Zespoły korzystające z treści internetowych lub szablonów HTML muszą wdrożyć niestandardową logikę konwersji.

Zaniechano konserwacji: Oryginalne repozytorium CodePlex nie istnieje, a rozgałęzienia na GitHubie nie są już aktywnie utrzymywane. Nie są opracowywane poprawki bezpieczeństwa, poprawki błędów ani nowe funkcje.

Ograniczenia platformy: FO.NET ma wewnętrzne zależności od System.Drawing, które uniemożliwiają jego działanie w systemach Linux/macOS, ograniczając wdrożenie wyłącznie do środowisk Windows. Nowoczesne aplikacje coraz częściej wymagają wdrażania na wielu platformach.

Brak nowoczesnych funkcji: brak obsługi JavaScript, brak funkcji CSS3 (Flexbox, Grid), brak nowoczesnych czcionek internetowych oraz brak możliwości bezpośredniego renderowania adresów URL.

Mocne strony i kwestie do rozważenia

Atuty FO.NET

  • Bezpośrednia konwersja XSL-FO: Zoptymalizowana specjalnie pod kątem konwersji z XSL-FO do PDF
  • Open Source: licencja Apache 2.0 — bezpłatne użytkowanie, modyfikowanie i rozpowszechnianie
  • Precyzyjna kontrola: XSL-FO zapewnia szczegółową kontrolę nad układem dokumentu

Uwagi dotyczące FO.NET

  • Technologia przestarzała: specyfikacja XSL-FO nie była aktualizowana od 2006 roku
  • Wymagana znajomość XSL-FO: mniej niż 1% programistów posiada tę wiedzę
  • Brak obsługi HTML: Nie można renderować treści HTML ani CSS
  • Porzucone: Brak aktywnej konserwacji lub aktualizacji zabezpieczeń
  • Tylko Windows: zależności od System.Drawing uniemożliwiają użycie na różnych platformach
  • Brak renderowania adresów URL: Nie można bezpośrednio konwertować stron internetowych
  • Ograniczona dokumentacja: zasoby są nieaktualne

Atuty IronPDF

  • Standard HTML/CSS: Wykorzystuje technologie internetowe, które zna już ponad 98% programistów
  • Modern Rendering: silnik Chromium z pełną obsługą CSS3 i JavaScript
  • Aktywny rozwój: comiesięczne wydania zawierające nowe funkcje i poprawki bezpieczeństwa
  • Wielopłatformowość: Pełna obsługa systemów Windows, Linux i macOS
  • Bezpośrednie renderowanie URL: Natywna funkcjonalność RenderUrlAsPdf()
  • Funkcje Professional: nagłówki, stopki, znaki wodne, zabezpieczenia — wszystko wbudowane
  • Kompleksowe zasoby: obszerne samouczki i dokumentacja

Uwagi dotyczące IronPDF

  • Licencja komercyjna: Wymagana jest licencja do użytku produkcyjnego
  • Inny paradygmat: szablony XSL-FO wymagają konwersji do formatu HTML

Wnioski

FO.NET iIronPDFreprezentują zasadniczo różne podejścia do generowania plików PDF w środowisku .NET. FO.NET służy do niszowego zastosowania, jakim jest konwersja XSL-FO do formatu PDF, ale jego oparcie na przestarzałej technologii, zaprzestanie wsparcia technicznego, ograniczenie do systemu Windows oraz brak obsługi HTML sprawiają, że coraz trudniej jest go uzasadnić w nowych projektach.

IronPDF oferuje nowoczesne podejście oparte na standardach internetowych HTML/CSS, które jest dostosowane do aktualnych umiejętności i technologii programistów. Możliwość bezpośredniego renderowania HTML, adresów URL oraz korzystania z pełnego CSS3 dzięki silnikowi Chromium sprawia, że rozwiązanie to doskonale nadaje się do współczesnych wymagań związanych z generowaniem plików PDF.

W miarę jak organizacje planują wdrożenie .NET 10, C# 14 oraz tworzenie aplikacji do 2026 r., podstawy technologiczne mają kluczowe znaczenie. Zespoły utrzymujące starsze systemy XSL-FO mogą nadal korzystać z FO.NET, ale przyszłość nowoczesnego generowania plików PDF wyraźnie wskazuje na rozwiązania oparte na HTML, takie jak IronPDF, które wykorzystują istniejącą wiedzę z zakresu tworzenia stron internetowych.

Zacznij testować IronPDF, korzystając z bezpłatnej wersji próbnej, i zapoznaj się z obszerną dokumentacją, aby ocenić, czy rozwiązanie to spełnia Twoje konkretne wymagania.