PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z Scryber.Core do IronPDF w języku C#

Zaktualizowano:maja 18, 2026

Migracja z Scryber.Core do IronPDF przenosi twój przepływ pracy generowania PDF z niestandardowego silnika układu XHTML+CSS na renderowarkę opartą naChromiumz pełnym wsparciem CSS3 i JavaScript. Niniejszy przewodnik zapewnia krok po kroku ścieżkę migracji, uwzględniając obowiązki licencyjne LGPL v3, jednoznaczny model szablonów XHTML Scryber oraz różnice w renderowaniu między tymi dwoma silnikami.

Dlaczego warto przejść z Scryber.Core na IronPDF

Zrozumienie Scryber.Core

Scryber.Core (utrzymywany przez Richarda Hewitsona, obecna wersja 9.3.1) to biblioteka open-source, która analizuje szablony XHTML+CSS za pomocą własnego silnika układu - nie przeglądarki. Obsługuje stylizację CSS, powiązanie danych w stylu Handlebars {{ }} za pomocą doc.Params oraz SVG, czyniąc go atrakcyjnym dla deweloperów, którzy chcą generować PDFy oparte na HTML bez zależności od przeglądarki.

Chociaż Scryber.Core jest możliwą opcją do generowania PDF z szablonów HTML, kilka ograniczeń zmusza zespoły do migracji.

Główne powody migracji

Obawy licencji LGPL v3: Obowiązki ujawnienia źródła są obowiązkowe, jeśli modyfikujesz sam Scryber; statyczne łączenie w aplikacjach zamkniętego źródła jest dozwolone, ale warunki nadal ograniczają sposób przesyłania modyfikacji.
Ścisły XHTML jako wejście: Szablony muszą być prawidłowym XML — większość realnych stron HTML wymaga czyszczenia, zanim Scryber je przetworzy.
Renderowanie spoza przeglądarki: Niestandardowy silnik układu XHTML/CSS — nowoczesne CSS (Grid, pełen Flexbox, zapytania kontenerowe) i jakikolwiekJavaScriptnie są wykonane.
Mniejsza społeczność: Mniej przykładów niż główne biblioteki.
Brak wykonań JavaScript: Statyczne renderowanie tylko - wykresy, SPA i dynamiczne widżety muszą być wstępnie renderowane.
Brak natywnego URL-do-PDF: Musisz pobrać HTML samodzielnie (np. za pomocą HttpClient) i wprowadzić go.
Wsparcie przez społeczność: Opcje wsparcia komercyjnego są ograniczone.

Porównanie Scryber.Core i IronPDF

Aspekt	Scryber.Core	IronPDF
Licencja	LGPL v3	Komercjalne
Silnik renderujący	Niestandardowy silnik układu XHTML/CSS	Chromium
Obsługa CSS	Podzbiór (bez Grid, częściowy Flexbox)	Pełny CSS3
JavaScript	Nie wykonane	Pełen (Chromium V8)
Powiązanie szablonów	Powiązanie w stylu Handlebars `{{ }}` + `<template>`	Standard (Razor, RazorLight, etc.)
Ścisłość wejścia	Wymaga dobrze zbudowanego XHTML	Akceptuje rzeczywisty HTML
Obsługa asynchroniczna	`PDFAsync` pomocnik MVC; sync core	Pełen asynchroniczny API
Dokumentacja	Strona read-the-docs + przykłady	Obszerne
Wsparcie społeczności	Mniejsze	Większa
Wsparcie komercyjne	Wsparcie przez społeczność	Dostępne wsparcie komercyjne

IronPDF oferuje wsparcie komercyjne, dokumentację i większą bazę użytkowników w porównaniu do Scryber.Core. Biblioteka jest licencjonowana do użytku komercyjnego bez zobowiązań LGPL.

Zanim zaczniesz

Wymagania wstępne

Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
Dostęp do NuGet: Możliwość instalowania pakietów NuGet
Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove Scryber.Core
dotnet remove package Scryber.Core

# Install IronPDF
dotnet add package IronPdf

# Remove Scryber.Core
dotnet remove package Scryber.Core

# Install IronPDF
dotnet add package IronPdf

SHELL

Konfiguracja licencji

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Kompletna dokumentacija API

Zmiany w przestrzeni nazw

// Before: Scryber.Core
using Scryber.Components;   // Document, Page, etc.
using Scryber.Drawing;      // Units, colours
using Scryber.PDF;          // RenderOptions / OutputCompressionType
using Scryber.Styles;       // Style elements (older XML template usage)

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: Scryber.Core
using Scryber.Components;   // Document, Page, etc.
using Scryber.Drawing;      // Units, colours
using Scryber.PDF;          // RenderOptions / OutputCompressionType
using Scryber.Styles;       // Style elements (older XML template usage)

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports Scryber.Components   ' Document, Page, etc.
Imports Scryber.Drawing      ' Units, colours
Imports Scryber.PDF          ' RenderOptions / OutputCompressionType
Imports Scryber.Styles       ' Style elements (older XML template usage)

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

$vbLabelText $csharpLabel

Mapowania podstawowych interfejsów API

Scryber.Core	IronPDF
`Document.ParseDocument(reader, "", ParseSourceType.DynamicContent)`	`renderer.RenderHtmlAsPdf(html)`
`Document.ParseDocument(path)`	`renderer.RenderHtmlFileAsPdf(path)`
`doc.SaveAsPDF(path)`	`pdf.SaveAs(path)`
`doc.SaveAsPDF(stream)`	`pdf.BinaryData` (`byte[]`)
`doc.Info.Title`	`pdf.MetaData.Title`
`doc.Info.Author`	`pdf.MetaData.Author`
`@page` CSS w szablonie	`renderer.RenderingOptions.PaperSize` / marginesy
`doc.RenderOptions`	`renderer.RenderingOptions`
Handlebars `{{value}}` + `doc.Params`	Razor / interpolacja ciągów

Przykłady migracji kodu

Przykład 1: Podstawowa konwersja HTML do PDF

Przed (Scryber.Core):

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

class Program
{
    static void Main()
    {
        // Scryber requires well-formed XHTML wrapped in an html root with the xhtml namespace
        string html = @"<html xmlns='http://www.w3.org/1999/xhtml'>
            <body><h1>Hello World</h1><p>This is a PDF document.</p></body>
        </html>";

        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("output.pdf", FileMode.Create))
        {
            doc.SaveAsPDF(stream);
        }
    }
}

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

class Program
{
    static void Main()
    {
        // Scryber requires well-formed XHTML wrapped in an html root with the xhtml namespace
        string html = @"<html xmlns='http://www.w3.org/1999/xhtml'>
            <body><h1>Hello World</h1><p>This is a PDF document.</p></body>
        </html>";

        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("output.pdf", FileMode.Create))
        {
            doc.SaveAsPDF(stream);
        }
    }
}

Imports Scryber.Components
Imports System.IO

Class Program
    Shared Sub Main()
        ' Scryber requires well-formed XHTML wrapped in an html root with the xhtml namespace
        Dim html As String = "<html xmlns='http://www.w3.org/1999/xhtml'>" &
                             "<body><h1>Hello World</h1><p>This is a PDF document.</p></body>" &
                             "</html>"

        Using reader As New StringReader(html),
              doc As Document = Document.ParseDocument(reader, String.Empty, ParseSourceType.DynamicContent),
              stream As New FileStream("output.pdf", FileMode.Create)
            doc.SaveAsPDF(stream)
        End Using
    End Sub
End Class

$vbLabelText $csharpLabel

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        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()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        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()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

        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

Scryber.Core opakowuje ciąg XHTML w StringReader, przekazuje go do Document.ParseDocument z użyciem ParseSourceType.DynamicContent i zapisuje PDF do FileStream za pomocą SaveAsPDF. Deklaracja przestrzeni nazw XHTML jest wymagana — Scryber odrzuci HTML, który nie jest dobrze zbudowanym XML.

IronPDF używa instancji ChromePdfRenderer z RenderHtmlAsPdf() do bezpośredniego renderowania HTML i zapisuje za pomocą SaveAs(). Z rzeczywistego HTML5 jest akceptowane jako jest. Zobacz dokumentację HTML do PDF dla dalszych przykładów.

Przykład 2: Konwersja adresów URL do formatu PDF

Przed (Scryber.Core):

// NuGet: Install-Package Scryber.Core
// Scryber has no native URL-to-PDF method — fetch the HTML yourself, then parse.
using Scryber.Components;
using System.IO;
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");

        // Most live HTML is not valid XHTML; expect to clean it
        // (e.g., HtmlAgilityPack) before Scryber will parse it.
        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("webpage.pdf", FileMode.Create))
        {
            doc.SaveAsPDF(stream);
        }
    }
}

// NuGet: Install-Package Scryber.Core
// Scryber has no native URL-to-PDF method — fetch the HTML yourself, then parse.
using Scryber.Components;
using System.IO;
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");

        // Most live HTML is not valid XHTML; expect to clean it
        // (e.g., HtmlAgilityPack) before Scryber will parse it.
        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("webpage.pdf", FileMode.Create))
        {
            doc.SaveAsPDF(stream);
        }
    }
}

Imports Scryber.Components
Imports System.IO
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")

            ' Most live HTML is not valid XHTML; expect to clean it
            ' (e.g., HtmlAgilityPack) before Scryber will parse it.
            Using reader As New StringReader(html)
                Using doc As Document = Document.ParseDocument(reader, String.Empty, ParseSourceType.DynamicContent)
                    Using stream As New FileStream("webpage.pdf", FileMode.Create)
                        doc.SaveAsPDF(stream)
                    End Using
                End Using
            End Using
        End Using
    End Function
End Module

$vbLabelText $csharpLabel

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        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()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

Scryber.Core nie ma natywnych punktów wejścia URL-do-PDF. Pobierasz HTML samodzielnie przy pomocy HttpClient.GetStringAsync() i wprowadzasz go do Document.ParseDocument(). Ponieważ Scryber wymaga dobrze zbudowanego XHTML, większość stron na żywo wymaga czyszczenia (na przykład przez HtmlAgilityPack) przed przetworzeniem.JavaScriptnie jest wykonywany, więc wszelkie dynamicznie renderowane treści będą brakować.

Moduł RenderUrlAsPdf() w IronPDF obsługuje pobieranie, wykonanie JavaScriptu i renderowanie CSS w jednym wywołaniu dzięki silnikowi Chromium. Dowiedz się więcej w naszych samouczkach.

Przykład 3: Niestandardowe ustawienia strony i marginesy

Przed (Scryber.Core):

// NuGet: Install-Package Scryber.Core
// Page size and margins are normally declared in the XHTML/CSS template;
// the runtime RenderOptions object exposes output-side settings such as compression.
using Scryber.Components;
using Scryber.PDF;
using System.IO;

class Program
{
    static void Main()
    {
        // Page size and margins go in CSS @page; this is the Scryber idiom.
        string html = @"<html xmlns='http://www.w3.org/1999/xhtml'>
            <head>
                <style>
                    @page { size: A4 portrait; margin: 40pt; }
                </style>
            </head>
            <body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body>
        </html>";

        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("custom.pdf", FileMode.Create))
        {
            // Output-side options (compression / conformance) are on RenderOptions.
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.SaveAsPDF(stream);
        }
    }
}

// NuGet: Install-Package Scryber.Core
// Page size and margins are normally declared in the XHTML/CSS template;
// the runtime RenderOptions object exposes output-side settings such as compression.
using Scryber.Components;
using Scryber.PDF;
using System.IO;

class Program
{
    static void Main()
    {
        // Page size and margins go in CSS @page; this is the Scryber idiom.
        string html = @"<html xmlns='http://www.w3.org/1999/xhtml'>
            <head>
                <style>
                    @page { size: A4 portrait; margin: 40pt; }
                </style>
            </head>
            <body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body>
        </html>";

        using (var reader = new StringReader(html))
        using (var doc = Document.ParseDocument(reader, string.Empty, ParseSourceType.DynamicContent))
        using (var stream = new FileStream("custom.pdf", FileMode.Create))
        {
            // Output-side options (compression / conformance) are on RenderOptions.
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.SaveAsPDF(stream);
        }
    }
}

Imports Scryber.Components
Imports Scryber.PDF
Imports System.IO

Module Program

    Sub Main()
        ' Page size and margins go in CSS @page; this is the Scryber idiom.
        Dim html As String = "<html xmlns='http://www.w3.org/1999/xhtml'>" &
                             "<head>" &
                             "<style>" &
                             "@page { size: A4 portrait; margin: 40pt; }" &
                             "</style>" &
                             "</head>" &
                             "<body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body>" &
                             "</html>"

        Using reader As New StringReader(html),
              doc As Document = Document.ParseDocument(reader, String.Empty, ParseSourceType.DynamicContent),
              stream As New FileStream("custom.pdf", FileMode.Create)

            ' Output-side options (compression / conformance) are on RenderOptions.
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode
            doc.SaveAsPDF(stream)
        End Using
    End Sub

End Module

$vbLabelText $csharpLabel

Po (IronPDF):

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        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()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        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()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

        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 Scryber.Core rozmiar strony i marginesy są zadeklarowane w szablonie za pomocą @page CSS, natomiast doc.RenderOptions udostępnia ustawienia po stronie wyjściowej, takie jak kompresja (OutputCompressionType.FlateDecode).

IronPDF przenosi geometrię strony do RenderingOptions w renderze: PaperSize (ustawiony na PdfPaperSize.A4), MarginTop i MarginBottom w milimetrach. Geometria strony istnieje na powierzchni API, a nie wewnątrz szablonu.

Szablony wzorców migracji

Migracja wiązania Scryber do standardowych szablonów

Scryber.Core używa XHTML z powiązaniami w stylu Handlebars {{ }} (rozwiązanymi za pomocą doc.Params) i konstrukcją <template data-bind='...'> dla powtarzających się sekcji. Aby zmigrować, wyraż je ponownie w standardowym szablonie .NET:

Wiązanie Scryber (XHTML + Handlebars):

<p>{{model.Name}}</p>
<p>Total: {{model.Total}}</p>
<template data-bind='{{model.Items}}'>
    <p>{{.Name}}: {{.Price}}</p>
</template>

<p>{{model.Name}}</p>
<p>Total: {{model.Total}}</p>
<template data-bind='{{model.Items}}'>
    <p>{{.Name}}: {{.Price}}</p>
</template>

XML

IronPDF z interpolacją ciągów znaków w języku C#:

var items = model.Items.Select(i => $"<li>{i.Name}: {i.Price:C}</li>");

var html = $@"
<p>{model.Name}</p>
<p>Total: {model.Total:C}</p>
<ul>
    {string.Join("", items)}
</ul>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

var items = model.Items.Select(i => $"<li>{i.Name}: {i.Price:C}</li>");

var html = $@"
<p>{model.Name}</p>
<p>Total: {model.Total:C}</p>
<ul>
    {string.Join("", items)}
</ul>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Dim items = model.Items.Select(Function(i) $"<li>{i.Name}: {i.Price:C}</li>")

Dim html = $"
<p>{model.Name}</p>
<p>Total: {model.Total:C}</p>
<ul>
    {String.Join("", items)}
</ul>"

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

$vbLabelText $csharpLabel

PonieważIronPDF akceptuje zwykły HTML, można używać dowolnego silnika szablonów .NET — Razor, RazorLight, Handlebars.Net — zamiast konstrukcji {{ }} + <template> w Scryber.

Migracja nagłówków i stopek

Scryber.Core (XHTML + @page margin boxes):

<html xmlns='http://www.w3.org/1999/xhtml'>
    <head>
        <style>
            @page {
                @top-center { content: 'Company Report'; }
                @bottom-center { content: 'Page ' counter(page) ' of ' counter(pages); }
            }
        </style>
    </head>
    <body>
        <h1>Content Here</h1>
    </body>
</html>

<html xmlns='http://www.w3.org/1999/xhtml'>
    <head>
        <style>
            @page {
                @top-center { content: 'Company Report'; }
                @bottom-center { content: 'Page ' counter(page) ' of ' counter(pages); }
            }
        </style>
    </head>
    <body>
        <h1>Content Here</h1>
    </body>
</html>

HTML

IronPDF (nagłówki/stopki 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

Scryber.Core definiuje nagłówki i stopki poprzez @page skrzynki marginesów w CSS, używając counter(page) i counter(pages) dla numeracji stron.IronPDF używa HtmlHeaderFooter z pełnym HTML/CSS dla nagłówków i stopek oraz z symbolami zastępczymi {page} i {total-pages}.

Nowe możliwości po migracji

Po migracji do IronPDF zyskujesz możliwości, których Scryber.Core nie jest w stanie zapewnić:

Łączenie plików PDF

var pdf1 = PdfDocument.FromFile("chapter1.pdf");
var pdf2 = PdfDocument.FromFile("chapter2.pdf");
var pdf3 = PdfDocument.FromFile("chapter3.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("complete_book.pdf");

var pdf1 = PdfDocument.FromFile("chapter1.pdf");
var pdf2 = PdfDocument.FromFile("chapter2.pdf");
var pdf3 = PdfDocument.FromFile("chapter3.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("complete_book.pdf");

Dim pdf1 = PdfDocument.FromFile("chapter1.pdf")
Dim pdf2 = PdfDocument.FromFile("chapter2.pdf")
Dim pdf3 = PdfDocument.FromFile("chapter3.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2, pdf3)
merged.SaveAs("complete_book.pdf")

$vbLabelText $csharpLabel

Bezpieczeństwo i metadane

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Metadata
pdf.MetaData.Title = "My Document";
pdf.MetaData.Author = "John Doe";
pdf.MetaData.Subject = "Annual Report";
pdf.MetaData.Keywords = "report, annual, confidential";

// Security
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Metadata
pdf.MetaData.Title = "My Document";
pdf.MetaData.Author = "John Doe";
pdf.MetaData.Subject = "Annual Report";
pdf.MetaData.Keywords = "report, annual, confidential";

// Security
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")

' Metadata
pdf.MetaData.Title = "My Document"
pdf.MetaData.Author = "John Doe"
pdf.MetaData.Subject = "Annual Report"
pdf.MetaData.Keywords = "report, annual, confidential"

' Security
pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user456"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

pdf.SaveAs("protected.pdf")

$vbLabelText $csharpLabel

Podsumowanie porównania funkcji

Funkcja	Scryber.Core	IronPDF
HTML do PDF	XHTML+CSS poprzez niestandardowy silnik układu	PełnyChromium
URL do pliku PDF	Tylko ręczne pobieranie	Natywne `RenderUrlAsPdf`
CSS Grid	Nieobsługiwane	Pełne wsparcie
Flexbox	Częściowe	Pełne wsparcie
JavaScript	Nie wykonane	Pełen (V8)
Powiązanie danych	`{{ }}` Handlebars + `doc.Params`	Razor / RazorLight / interpolation
Nagłówki/stopki	`@page` skrzynki marginesów / sekcje szablonów	`HtmlHeaderFooter` z `{page}` `{total-pages}`
Łączenie plików PDF	Nieobsługiwane	Wbudowane `PdfDocument.Merge`
Podział plików PDF	Nieobsługiwane	Tak
Znaki wodne	Przez nakładkę HTML w szablonie	Natywne `ApplyStamp` / `ApplyWatermark`
Podpisy cyfrowe	Nieobsługiwane	Tak
PDF/A	Nieobsługiwane	Tak (PDF/A-1b, PDF/A-3)
Ochrona hasłem	Nieobsługiwane	Pełen (użytkownik/właściciel + uprawnienia)
Obsługa asynchroniczna	`PDFAsync` pomocnik MVC; sync core	Pełen asynchroniczna powierzchnia
Wielopłatformowe	Tak (.NET Std 2.0/2.1, .NET 8/9/10)	Tak

Lista kontrolna migracji

Przed migracją

Zweryfikuj wszystkie szablony Scryber w poszukiwaniu wzorców XHTML/wiązań
Wzorce powiązania danych dokumentu ({{model.Property}})
Zidentyfikuj niestandardowe style wymagające konwersji CSS
Uzyskaj klucz licencyjny IronPDF ze strony ironpdf.com

Aktualizacje kodu

Usuń Scryber.Core pakiet NuGet
Zainstaluj IronPdf pakiet NuGet
Zaktualizuj importy przestrzeni nazw (using Scryber.Components; / Scryber.Drawing; / Scryber.PDF; → using IronPdf;)
Zastąp Document.ParseDocument(reader, "", ParseSourceType.DynamicContent) przez renderer.RenderHtmlAsPdf(html)
Zastąp doc.SaveAsPDF(stream) przez pdf.SaveAs(path) lub pdf.BinaryData
Przekształć szablony XHTML na zwykły HTML5 (bez wymogu przestrzeni nazw)
Zastąp powiązanie w stylu Handlebars {{ }} na standardowe szablonowanie (Razor / interpolacja ciągów)
Przenieś @page CSS do renderer.RenderingOptions (RozmiarPapieru, GórnyMargines, itp.)
Przekonwertuj nagłówki/stopki skrzynki marginesów @page na HtmlHeaderFooter z symbolami zastępczymi {page} i {total-pages}
Dodaj inicjalizację licencji podczas uruchamiania aplikacji

Testowanie

Przetestuj wszystkie szablony dokumentów
Sprawdź zgodność stylów (wykorzystaj pełną obsługę CSS)
Testowanie powiązania danych z nowymi szablonami
Sprawdź podziały stron
Przetestuj nagłówki/stopki z symbolami zastępczymi numerów stron
Porównanie wydajności

Zwróć uwagęScryber jest zastrzeżonym znakiem towarowym swojego właściciela. Ta strona nie jest powiązana z, popierana ani sponsorowana przez PerceiveIT Limited. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

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

Zaktualizowano maja 18, 2026

Jak przeprowadzić migrację z ZetPDF do IronPDF w języku C#

Opanuj migrację z ZetPDF do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź z biblioteki opartej na współrzędnych na nowoczesne rozwiązanie do konwersji HTML na PDF. Zawiera przykłady kodu dotyczące konwersji HTML, łączenia plików PDF oraz usuwania zależności od PDFSharp.

Czytaj więcej

Zaktualizowano maja 18, 2026

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

Opanuj migrację z XFINIUM.PDF do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź od ręcznego pozycjonowania opartego na współrzędnych do deklaratywnego renderowania HTML/CSS. Zawiera przykłady kodu dotyczące zastępowania prymitywów graficznych i automatycznego układu.

Czytaj więcej

Zaktualizowano maja 18, 2026

Jak przeprowadzić migrację z PdfPig do IronPDF w języku C#

Opanuj migrację z PdfPig do IronPDF dzięki temu kompletnemu przewodnikowi w języku C#. Przejdź z biblioteki tylko do odczytu na kompleksowe rozwiązanie do obsługi plików PDF. Zawiera przykłady kodu do wyodrębniania tekstu, konwersji HTML i dostępu do metadanych.

Czytaj więcej

Jak przeprowadzić migrację z SelectPdf do IronPDF w języku C#

Jak przeprowadzić migrację z SAP ...

Zwycięstwo klienta:

Podkreślaj programistę:

Webinary:

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

Jak przeprowadzić migrację z Scryber.Core do IronPDF w języku C#

Dlaczego warto przejść z Scryber.Core na IronPDF

Zrozumienie Scryber.Core

Główne powody migracji

Porównanie Scryber.Core i IronPDF

Zanim zaczniesz

Wymagania wstępne

Zmiany w pakiecie NuGet

Konfiguracja licencji

Kompletna dokumentacija API

Zmiany w przestrzeni nazw

Mapowania podstawowych interfejsów API

Przykłady migracji kodu

Przykład 1: Podstawowa konwersja HTML do PDF

Przykład 2: Konwersja adresów URL do formatu PDF

Przykład 3: Niestandardowe ustawienia strony i marginesy

Szablony wzorców migracji

Migracja wiązania Scryber do standardowych szablonów

Migracja nagłówków i stopek

Nowe możliwości po migracji

Łączenie plików PDF

Bezpieczeństwo i metadane

Podsumowanie porównania funkcji

Lista kontrolna migracji

Przed migracją

Aktualizacje kodu

Testowanie

Twój klucz licencyjny został dostarczony do Twojej skrzynki odbiorczej

Twoje zgłoszenie demo jest przetwarzane.

Zespół wsparcia Iron

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

Jak przeprowadzić migrację z Scryber.Core do IronPDF w języku C#

Dlaczego warto przejść z Scryber.Core na IronPDF

Zrozumienie Scryber.Core

Główne powody migracji

Porównanie Scryber.Core i IronPDF

Zanim zaczniesz

Wymagania wstępne

Zmiany w pakiecie NuGet

Konfiguracja licencji

Kompletna dokumentacija API

Zmiany w przestrzeni nazw

Mapowania podstawowych interfejsów API

Przykłady migracji kodu

Przykład 1: Podstawowa konwersja HTML do PDF

Przykład 2: Konwersja adresów URL do formatu PDF

Przykład 3: Niestandardowe ustawienia strony i marginesy

Szablony wzorców migracji

Migracja wiązania Scryber do standardowych szablonów

Migracja nagłówków i stopek

Nowe możliwości po migracji

Łączenie plików PDF

Bezpieczeństwo i metadane

Podsumowanie porównania funkcji

Lista kontrolna migracji

Przed migracją

Aktualizacje kodu

Testowanie

Powiązane artykuły

Jak przeprowadzić migrację z ZetPDF do IronPDF w języku C#

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

Jak przeprowadzić migrację z PdfPig do IronPDF w języku C#

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Thank You

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Chcesz wdrożyć IronSuite w projekcie na żywo za DARMO?

Co jest wliczone?

Twój klucz licencyjny został dostarczony do Twojej skrzynki odbiorczej

Twoje zgłoszenie demo jest przetwarzane.

Zaufane przez miliony inżynierów na całym świecie

Zespół wsparcia Iron