PORóWNANIE

Scryber.Core vs IronPDF: Przewodnik porównania technicznego

Zaktualizowano:

Kiedy programiści .NET oceniają rozwiązania do generowania plików PDF, Scryber.Core iIronPDFreprezentują różne podejścia z odmiennymi filozofiami architektury i modelami licencjonowania. Scryber.Core udostępnia bibliotekę open source wykorzystującą szablony XML/HTML z niestandardowym silnikiem parsującym, natomiastIronPDFoferuje silnik renderujący oparty na Chromium, zaprojektowany z myślą o wysokiej jakości konwersji HTML do PDF. W niniejszym porównaniu technicznym przeanalizowano obie biblioteki pod kątem aspektów, które mają największe znaczenie dla profesjonalnych programistów i architektów podejmujących decyzje dotyczące generowania plików PDF dla aplikacji .NET w 2025 roku i później.

Zrozumienie Scryber.Core

Scryber.Core to biblioteka open source, która przekształca szablony HTML w pliki PDF przy użyciu języka C#. Biblioteka wykorzystuje wszechstronność HTML i możliwości stylizacji CSS, aby zapewnić podejście do generowania plików PDF oparte na szablonach. Scryber.Core wykorzystuje niestandardowy silnik analizujący zamiast renderera opartego na przeglądarce, przetwarzając dokumenty poprzez swoją zastrzeżoną metodę Document.ParseDocument().

Biblioteka działa na licencji LGPL, co oznacza, że korzystanie z Scryber.Core w projektach nie wiąże się z żadnymi bezpośrednimi kosztami, o ile programiści przestrzegają warunków licencji LGPL. Jednak ten model licencyjny wymaga, aby wszelkie modyfikacje samej biblioteki były udostępniane na licencji open source, co może stanowić ograniczenie dla niektórych zastosowań komercyjnych.

Kluczowa uwaga: Scryber.Core wykorzystuje własną składnię wiązania dla szablonów danych oraz podejścia konfiguracyjne oparte w dużej mierze na XML. Biblioteka nie wykonuje kodu JavaScript, zapewniając jedynie statyczne renderowanie z ograniczoną obsługą CSS w porównaniu z rozwiązaniami opartymi na przeglądarkach.

Zrozumienie IronPDF

IronPDF oferuje komercyjną bibliotekę do generowania plików PDF, która wykorzystuje silnik renderujący oparty na Chromium. Biblioteka konwertuje HTML, CSS iJavaScriptna dokumenty PDF z pełną wiernością na poziomie przeglądarki, obsługując nowoczesne funkcje CSS3, w tymFlexboxi CSS Grid, a także zapewniając pełną obsługęJavaScriptES2024.

IronPDF instaluje się jako pakiet NuGet bez ograniczeń licencyjnych związanych z LGPL. Biblioteka zapewnia obszerną dokumentację, profesjonalne wsparcie oraz większą społeczność w porównaniu z alternatywnymi rozwiązaniami open source.

Porównanie architektury

Podstawowe różnice między Scryber.Core aIronPDFmają wpływ na możliwości renderowania i procesy programistyczne:

Aspekt Scryber.Core IronPDF
Licencja LGPL (restrykcyjna) Komercjalne
Silnik renderujący Niestandardowy parser Chromium
Obsługa CSS Ograniczone Pełny CSS3
JavaScript Nie Pełna wersja ES2024
Powiązanie szablonów Własny format XML Standard (Razor itp.)
Krzywa uczenia się Niestandardowa składnia StandardowyHTML/CSS
Obsługa asynchroniczna Ograniczone Pełna
Dokumentacja Podstawowe Obszerne

Tabela porównawcza funkcji

Funkcja Scryber.Core IronPDF
HTML do PDF Podstawowe PełnyChromium
URL do pliku PDF Wymagane ręczne pobieranie Wsparcie native
CSS Grid Ograniczone Obsługiwane
Flexbox Ograniczone Obsługiwane
JavaScript Nie Pełna wersja ES2024
Powiązanie danych Własny format XML Użyj Razor/Handlebars
Nagłówki/stopki Oparty na XML HTML/CSS
Łączenie plików PDF Ograniczone Wbudowane
Podział plików PDF Nie Tak
Znaki wodne Podstawowe Pełny kod HTML
Podpisy cyfrowe Nie Tak
PDF/A Nie Tak
Ochrona hasłem Podstawowe Pełna
Wielopłatformowe Tak Tak

Konwersja HTML do PDF

Podstawowy proces konwersji HTML do PDF pokazuje zasadnicze różnice w API między bibliotekami.

Konwersja HTML Scryber.Core

Scryber.Core używa metody Document.ParseDocument() z niestandardowym silnikiem analizującym:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("output.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("output.pdf");
        }
    }
}
Imports Scryber.Core
Imports Scryber.Core.Html
Imports System.IO

Class Program
    Shared Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

        Using doc = Document.ParseDocument(html, ParseSourceType.DynamicContent)
            doc.SaveAsPDF("output.pdf")
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Takie podejście wymaga:

  • Jawne oświadczenie using dla właściwego zarządzania zasobami
  • Parametr ParseSourceType.DynamicContent dla analizowania ciągów HTML
  • API oparte na dokumentach, które różni się od standardowych wzorców renderowania HTML

Konwersja HTML w IronPDF

IronPDF dostarcza klasę ChromePdfRenderer z bezpośrednią konwersją HTML:

// 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 document.</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 document.</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 document.</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Metoda RenderHtmlAsPdf wykorzystuje silnik renderującyChromiumdo przetwarzania kodu HTML z pełną obsługą CSS i JavaScript. API działa według prostego schematu "renderuj, a potem zapisz", bez konieczności używania specjalnej składni do zarządzania zasobami.

Konwersja adresów URL do formatu PDF

Konwersja aktywnych stron internetowych do formatu PDF ujawnia znaczną różnicę w możliwościach obu bibliotek.

Obsługa adresów URL w Scryber.Core

Scryber.Core nie może bezpośrednio renderować adresów URL — programiści muszą ręcznie pobierać zawartość HTML:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        string html = await client.GetStringAsync("https://www.example.com");

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("webpage.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        string html = await client.GetStringAsync("https://www.example.com");

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("webpage.pdf");
        }
    }
}
Imports Scryber.Core
Imports Scryber.Core.Html
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using client As New HttpClient()
            Dim html As String = Await client.GetStringAsync("https://www.example.com")

            Using doc = Document.ParseDocument(html, ParseSourceType.DynamicContent)
                doc.SaveAsPDF("webpage.pdf")
            End Using
        End Using
    End Function
End Module
$vbLabelText   $csharpLabel

Podejście oparte na obejściu:

  • Wymaga jawnego zarządzania klientem HTTP
  • Pobiera surowy kod HTML bez wykonywania kodu JavaScript
  • Nie można przechwycić treści renderowanych dynamicznie
  • Utrata względnych odwołań do zasobów (obrazy, arkusze stylów)

Konwersja adresów URL w IronPDF

IronPDF zapewnia natywną konwersję adresów URL do formatu PDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.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://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf

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

Metoda RenderUrlAsPdf przechodzi do adresu URL przy użyciu silnika Chromium, wykonuje kod JavaScript, stosuje style CSS i przechwytuje w pełni wyrenderowaną stronę jako dokument PDF.

Niestandardowe ustawienia renderowania

Opcje konfiguracji strony i renderowania pokazują różne podejścia do API.

Ustawienia niestandardowe Scryber.Core

Scryber.Core konfiguruje ustawienia poprzez właściwość dokumentu RenderOptions:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.RenderOptions.PaperSize = PaperSize.A4;
            doc.SaveAsPDF("custom.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.RenderOptions.PaperSize = PaperSize.A4;
            doc.SaveAsPDF("custom.pdf");
        }
    }
}
Imports Scryber.Core
Imports Scryber.Core.Html
Imports Scryber.Drawing
Imports System.IO

Class Program
    Shared Sub Main()
        Dim html As String = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>"

        Using doc = Document.ParseDocument(html, ParseSourceType.DynamicContent)
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode
            doc.RenderOptions.PaperSize = PaperSize.A4
            doc.SaveAsPDF("custom.pdf")
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Konfiguracja następuje po przeanalizowaniu dokumentu, ale przed jego zapisaniem. Konfiguracja marginesów wymaga dodatkowego stylizowania opartego na XML lub programowej manipulacji sekcjami strony.

Ustawienia niestandardowe IronPDF

IronPDF konfiguruje ustawienia poprzez właściwość renderera RenderingOptions przed konwersją:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

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

        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

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

        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

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

        Dim html As String = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Właściwość RenderingOptions zapewnia bezpośredni dostęp do rozmiaru papieru, marginesów i innych ustawień PDF poprzez właściwości o silnym typowaniu. Renderer można skonfigurować jednorazowo i wykorzystywać go wielokrotnie do różnych konwersji.

Przewodnik po mapowaniu API

Zespoły oceniające migrację Scryber.Core doIronPDFmogą skorzystać z poniższego zestawienia równoważnych operacji:

Scryber.Core IronPDF
Document.ParseDocument(html) renderer.RenderHtmlAsPdf(html)
Document.ParseTemplate(path) renderer.RenderHtmlFileAsPdf(path)
doc.SaveAsPDF(path) pdf.SaveAs(path)
doc.SaveAsPDF(stream) pdf.Stream lub pdf.BinaryData
doc.Info.Title pdf.MetaData.Title
doc.Info.Author pdf.MetaData.Author
PDFPage pdf.Pages[i]
PDFLayoutDocument RenderingOptions
PDFStyle CSS w HTML
Powiązanie danych ({{value}}) Interpolacja Razor/String
doc.RenderOptions.PaperSize renderer.RenderingOptions.PaperSize

Różnica w powiązaniu szablonów

Scryber.Core wykorzystuje autorską składnię wiązania opartą na XML, która wymaga nauki niestandardowego języka szablonów:


<?xml version='1.0' encoding='utf-8' ?>
<pdf:Document xmlns:pdf='http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Components.xsd'>
    <Pages>
        <pdf:Section>
            <Header>
                <pdf:Para text='Company Report' />
            </Header>
            <Footer>
                <pdf:Para text='Page {{pagenum}} of {{pagetotal}}' />
            </Footer>
            <Content>
                <pdf:H1 text='Content Here' />
            </Content>
        </pdf:Section>
    </Pages>
</pdf:Document>

<?xml version='1.0' encoding='utf-8' ?>
<pdf:Document xmlns:pdf='http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Components.xsd'>
    <Pages>
        <pdf:Section>
            <Header>
                <pdf:Para text='Company Report' />
            </Header>
            <Footer>
                <pdf:Para text='Page {{pagenum}} of {{pagetotal}}' />
            </Footer>
            <Content>
                <pdf:H1 text='Content Here' />
            </Content>
        </pdf:Section>
    </Pages>
</pdf:Document>
XML

Takie podejście wymaga plików szablonów XML z zastrzeżonymi deklaracjami przestrzeni nazw i nazwami elementów.

Nagłówki i stopki IronPDF

IronPDF zapewnia w pełni programową konfigurację nagłówków i stopek opartą na HTML:

using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML header with full CSS support
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt; border-bottom: 1px solid #ccc;'>
            Company Report
        </div>",
    MaxHeight = 30
};

// HTML footer with page numbers
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content Here</h1>");
pdf.SaveAs("report.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML header with full CSS support
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt; border-bottom: 1px solid #ccc;'>
            Company Report
        </div>",
    MaxHeight = 30
};

// HTML footer with page numbers
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content Here</h1>");
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' HTML header with full CSS support
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 12pt; border-bottom: 1px solid #ccc;'>
            Company Report
        </div>",
    .MaxHeight = 30
}

' HTML footer with page numbers
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    .MaxHeight = 25
}

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Content Here</h1>")
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Klasa HtmlHeaderFooter wIronPDFumożliwia pełne stylizowanieHTML/CSSz użyciem symboli zastępczych {page} i {total-pages} dla dynamicznego numerowania stron.

Kwestie związane z licencją LGPL

Licencja LGPL Scryber.Core nakłada określone obowiązki, które mają wpływ na zastosowania komercyjne:

Wymagania LGPL:

  • Wszelkie modyfikacje samej biblioteki Scryber.Core muszą być udostępniane na licencji open source
  • Aplikacje muszą umożliwiać użytkownikom zastąpienie biblioteki LGPL zmodyfikowanymi wersjami
  • W niektórych scenariuszach dystrybucji komercyjnej może być wymagańe ujawnienie źródła.

Licencja komercyjna IronPDF:

  • Brak wymogów dotyczących ujawniania źródła
  • Brak ograniczeń dotyczących modyfikacji lub dystrybucji
  • Przejrzyste licencjonowanie bez złożonych kwestii związanych z zgodnością
  • W cenie profesjonalne wsparcie

Dla organizacji rozważających długoterminowe wdrożenie komercyjne różnice w modelach licencyjnych mają znaczący wpływ na planowanie prawne i zgodność z przepisami.

Kiedy zespoły rozważają migrację do Scryber.Core

Kilka czynników skłania zespoły programistów do rozważenia alternatyw dla Scryber.Core:

Kwestie związane z licencją LGPL mają wpływ na aplikacje komercyjne, w których obowiązki ujawniania kodu źródłowego kolidują z wymaganiami biznesowymi. Licencja komercyjnaIronPDFznosi te ograniczenia.

Ograniczona obsługa CSS staje się problemem, gdy projekty wykorzystują nowoczesne funkcje CSS. Niestandardowy parser Scryber.Core nie obsługuje Flexbox,CSS Gridani złożonych stylów, które silnik oparty naChromiumobsługuje natywnie.

Brak możliwości wykonywania kodu JavaScript blokuje dynamiczne renderowanie treści. Aplikacje jednostronicowe, wykresy i treści interaktywne wymagają wykonania kodu JavaScript, czego Scryber.Core nie jest w stanie zapewnić.

Zastrzeżona składnia szablonów wydłuża czas nauki i utrudnia wdrażanie nowych programistów. Zespoły zaznajomione zHTML/CSSmuszą nauczyć się niestandardowej składni wiązania Scryber, zamiast wykorzystywać dotychczasowe umiejętności.

Mniejsza społeczność oznacza mniej zasobów do rozwiązywania problemów i mniej dokumentacji stron trzecich. Szersza społecznośćIronPDFzapewnia więcej przykładów i zasobów wsparcia.

Ograniczona obsługa asynchroniczności wpływa na skalowalność aplikacji. Nowoczesne aplikacje .NET przeznaczone dla platformy .NET 10 i języka C# 14 w 2026 r. korzystają z pełnej obsługi async/await w całym procesie generowania plików PDF.

Zalety i kompromisy

Atuty Scryber.Core

  • Oprogramowanie open source bez bezpośrednich kosztów licencji (wymagańa zgodność z LGPL)
  • Obsługa wielu platform w środowiskach .NET
  • Podejście oparte na szablonach HTML dla programistów zaznajomionych z technologiami internetowymi
  • Odpowiednie dla projektów, w których warunki licencji LGPL są zgodne z modelem biznesowym

Ograniczenia Scryber.Core

  • Licencja LGPL ogranicza niektóre zastosowania komercyjne
  • Niestandardowy silnik parsujący z ograniczoną obsługą CSS
  • Brak wykonywania koduJavaScript(tylko renderowanie statyczne)
  • Zastrzeżona składnia powiązania XML wymaga pewnego nakładu pracy, aby się jej nauczyć
  • Mniejsza społeczność z mniejszą ilością dokumentacji
  • Ograniczona obsługa asynchroniczności
  • Brak wbudowanej funkcji konwersji adresów URL do formatu PDF
  • Brak funkcji manipulacji plikami PDF (łączenie, dzielenie, podpisy)

Atuty IronPDF

  • Pełne renderowanieChromiumz obsługą CSS3 iJavaScriptES2024
  • Natywna konwersja adresów URL do formatu PDF
  • Standardowe szablonyHTML/CSS(użyj Razor, Handlebars lub zwykłego HTML)
  • Licencja komercyjna bez ograniczeń LGPL
  • Obszerna dokumentacja i profesjonalne wsparcie
  • Pełna obsługa async/await
  • Funkcje edycji plików PDF (łączenie, dzielenie, znaki wodne)
  • Podpisy cyfrowe i funkcje bezpieczeństwa
  • Obsługa zgodności z PDF/A

Uwagi dotyczące IronPDF

  • Model licencji komercyjnej wymaga zakupu
  • SilnikChromiumzajmuje więcej miejsca niż niestandardowe parsery

Wnioski

Scryber.Core iIronPDFsłużą różnym kontekstom organizacyjnym i wymaganiom technicznym. Scryber.Core stanowi opcję open source dla programistów poszukujących narzędzia do generowania plików PDF na licencji LGPL z wykorzystaniem szablonów HTML i gotowych do pracy w ramach niestandardowej składni biblioteki oraz ograniczeń renderowania.

W przypadku aplikacji wymagających nowoczesnego renderowania CSS, wykonywania kodu JavaScript, natywnej konwersji adresów URL lub licencji komercyjnych bez zobowiązań wynikających z licencji LGPL,IronPDFzapewnia kompleksowe możliwości dzięki silnikowi opartemu na Chromium. Możliwość korzystania ze standardowych szablonów HTML/CSS, wykorzystania istniejących umiejętności w zakresie tworzenia stron internetowych oraz dostępu do funkcji manipulacji plikami PDF pozwala przezwyciężyć typowe ograniczenia, z jakimi borykają się zespoły korzystające z rozwiązań opartych na niestandardowych parserach.

Oceniając migrację Scryber.Core do IronPDF, zespoły powinny wziąć pod uwagę swoje konkretne wymagania dotyczące złożoności CSS, potrzeb związanych z JavaScript, preferencji licencyjnych oraz preferencji dotyczących przepływu pracy z szablonami. Dla zespołów skupiających się na nowoczesnych platformach .NET z internetowymi procesami projektowymi architekturaIronPDFbardziej naturalnie wpisuje się we współczesne praktyki programistyczne.

Aby uzyskać wskazówki dotyczące wdrożenia, zapoznaj się z samouczkiem IronPDF dotyczącym konwersji HTML do PDF oraz dokumentacją obejmującą wzorce generowania plików PDF dla aplikacji .NET.