La Bibliothèque PDF C#

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDÉOS

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Curtis Chau

Updated: 19 juillet 2026

La migration de Scryber.Core vers IronPDF déplace votre flux de travail de génération de PDF d'un moteur de mise en page XHTML+CSS personnalisé vers un moteur de rendu basé sur Chromeavec un support complet de CSS3 et JavaScript. Ce guide fournit un chemin de migration étape par étape couvrant les considérations de licence LGPL v3, le modèle de modèle XHTML strict de Scryber, et les différences de rendu entre les deux moteurs.

Pourquoi migrer de Scryber.Core vers IronPDF

Comprendre Scryber.Core

Scryber.Core (maintenu par Richard Hewitson, version actuelle 9.3.1) est une bibliothèque open-source qui analyse les modèles XHTML+CSS avec son propre moteur de mise en page — pas un navigateur. Il prend en charge le style CSS, la liaison de données {{ }} de type Handlebars via doc.Params et le SVG, ce qui le rend attrayant pour les développeurs qui souhaitent des PDF générés par HTML sans dépendance de navigateur.

Bien que Scryber.Core soit une option viable pour la génération de PDF basée sur des modèles HTML, plusieurs contraintes poussent les équipes à migrer.

Principales raisons de migrer

Préoccupations de licenceLGPL v3: Les obligations de divulgation de source s'appliquent si vous modifiez Scryber lui-même ; la liaison statique dans les apps à code source fermé est autorisée, mais les termes contraignent toujours la manière dont vous livrez les modifications.
Saisie XHTML stricte : Les modèles doivent être du XML valide — la plupart des HTML du monde réel nécessitent un nettoyage avant que Scryber ne puisse les analyser.
Moteur de rendu non-navigateur : Un moteur de mise en page XHTML/CSS personnalisé — le CSS moderne (Grid, Flexboxcomplet, requêtes de conteneurs) et tout JavaScriptne sont pas exécutés.
Communauté plus petite : Moins d'exemples pratiques que les bibliothèques grand public.
Pas d'exécution JavaScript: Rendu statique uniquement — les graphiques, les SPAs et les widgets dynamiques doivent être prérendus.
Pas de document PDF à URL native : Vous devez récupérer le HTML vous-même (par exemple, avec HttpClient) et l'alimenter.
Soutenu par la communauté : Les options de support commercial sont limitées.

Comparaison Scryber.Core vs IronPDF

Aspect	Scryber.Core	IronPDF
Licence	LGPL v3	Commercial
Moteur de rendu	Moteur de mise en page XHTML/CSS personnalisé	Chrome
Support CSS	Sous-ensemble (pas de grid, Flexboxpartiel)	CSS3 complet
JavaScript	Non exécuté	Complet (Chromium V8)
Reliure de modèle	Liaison `{{ }}` + `<template>` de style Handlebars	Standard (Razor, RazorLight, etc.)
Rigueur d'entrée	Nécessite du XHTML bien formé	Accepte le HTML du monde réel
Prise en charge de l'asynchronisme	`PDFAsync` assistant MVC ; sync core	API asynchrone complète
Documentation	Site read-the-docs + échantillons	Une traduction
Soutien à la communauté	Plus petit	Plus large
Soutien commercial	Soutenu par la communauté	Support commercial disponible

IronPDF offre un support commercial, une documentation et une base d'utilisateurs plus large comparée à Scryber.Core. La bibliothèque est licenciée pour un usage commercial sans obligations LGPL.

Avant de commencer

Prérequis

Environnement .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
Accès à NuGet : possibilité d'installer des packages NuGet
Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet 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

Configuration de la licence

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

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

Référence API complète

Modifications de l'espace de nommage

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

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

Mappages de l'API de base

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 dans le template	`renderer.RenderingOptions.PaperSize` / marges
`doc.RenderOptions`	`renderer.RenderingOptions`
Handlebars `{{value}}` + `doc.Params`	Razor / interpolation de chaîne

Exemples de migration de code

Exemple 1 : Conversion de base de HTML en PDF

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

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

Après (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

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

Scryber.Core enrobe la chaîne XHTML dans un StringReader, le transmet à Document.ParseDocument avec ParseSourceType.DynamicContent, et écrit le PDF à un FileStream via SaveAsPDF. La déclaration de namespace XHTML est requise — Scryber rejetera le HTML qui n'est pas du XML bien formé.

IronPDF utilise une instance ChromePdfRenderer avec RenderHtmlAsPdf() pour rendre HTML directement, et enregistre avec SaveAs(). Le HTML5 du monde réel est accepté tel quel. Voir la documentation HTML vers PDF pour d'autres exemples.

Exemple 2 : Conversion d'une URL en PDF

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

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

Après (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

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

Scryber.Core n'a pas de point d'entrée natif URL en PDF. Vous récupérez le HTML vous-même avec HttpClient.GetStringAsync() et l'alimentez dans Document.ParseDocument(). Parce que Scryber nécessite du XHTML bien formé, la plupart des pages en direct auront besoin d'un nettoyage (par exemple via HtmlAgilityPack) avant qu'elles ne soient analysées. Le JavaScriptn'est pas exécuté, donc tout contenu rendu dynamiquement sera manquant.

Le RenderUrlAsPdf() d'IronPDF gère la récupération, l'exécution JavaScriptet le rendu CSS en un seul appel via son moteur Chromium. Apprenez-en davantage dans nos tutoriels.

Exemple 3 : Paramètres et marges de page personnalisés

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

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

Après (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

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

Dans Scryber.Core, la taille de la page et les marges sont déclarées dans le template via @page CSS, tandis que doc.RenderOptions expose des paramètres côté sortie tels que la compression (OutputCompressionType.FlateDecode).

IronPDF déplace la géométrie de la page vers RenderingOptions sur le moteur de rendu : PaperSize (réglé sur PdfPaperSize.A4), MarginTop et MarginBottom en millimètres. La géométrie de la page se trouve sur la surface de l'API plutôt qu'à l'intérieur du modèle.

Modèles de migration de modèles

Migrer la liaison Scryber vers les modèles standards

Scryber.Core utilise du XHTML avec des liaisons de style {{ }} Handlebars (résolues via doc.Params) et une structure <template data-bind='...'> pour les sections répétées. Pour migrer, réexprimez-les dans la modélisation standard .NET :

Liaison 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 avec l'interpolation de chaînes en 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)

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)

Parce qu'IronPDF accepte du HTML simple, vous pouvez utiliser n'importe quel moteur de template .NET - Razor, RazorLight, Handlebars.Net - plutôt que {{ }} + <template> de Scryber.

Migration des en-têtes et pieds de page

Scryber.Core (XHTML + @page boîtes de marge) :

<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 (en-têtes/pieds de page 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")

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

Scryber.Core définit les en-têtes et pieds de page via des boîtes de marge @page dans CSS, utilisant counter(page) et counter(pages) pour les numéros de page.IronPDF utilise HtmlHeaderFooter avec HTML/CSS complet pour les en-têtes et pieds de page et les espaces réservés {page} et {total-pages}.

Nouvelles capacités après la migration

Après avoir migré vers IronPDF, vous bénéficiez de fonctionnalités que Scryber.Core ne peut pas vous offrir :

Fusion de fichiers 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")

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

Sécurité et métadonnées

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

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

Résumé de la comparaison des fonctionnalités

Fonction	Scryber.Core	IronPDF
HTML vers PDF	XHTML+CSS via moteur de mise en page personnalisé	Chromecomplet
URL vers PDF	Extraction manuelle uniquement	Natif `RenderUrlAsPdf`
Grille CSS	Non pris en charge	Prise en charge complète
Flexbox	Partiel	Prise en charge complète
JavaScript	Non exécuté	Complet (V8)
Liaison de données	`{{ }}` Handlebars + `doc.Params`	Razor / RazorLight / interpolation
En-têtes/Pieds de page	`@page` boîtes de marge / sections de template	`HtmlHeaderFooter` avec `{page}` `{total-pages}`
Fusionner des PDF	Non pris en charge	Intégré `PdfDocument.Merge`
Diviser les PDF	Non pris en charge	Oui
Filigranes	Via HTML superposé dans le modèle	Natif `ApplyStamp` / `ApplyWatermark`
Signatures numériques	Non pris en charge	Oui
PDF/A	Non pris en charge	Oui (PDF/A-1b, PDF/A-3)
Protection par mot de passe	Non pris en charge	Complet (utilisateur/propriétaire + autorisations)
Prise en charge de l'asynchronisme	`PDFAsync` assistant MVC ; sync core	Surface asynchrone complète
Multiplateforme	Oui (.NET Std 2.0/2.1, .NET 8/9/10)	Oui

Liste de contrôle de la migration

Pré-migration

Auditer tous les modèles Scryber pour les modèles XHTML/liaison
Modèles de liaison de données document utilisés ({{model.Property}})
Identifier les styles personnalisés nécessitant une conversion CSS
Obtenez votre clé de licence IronPDF sur IronPDF

Mises à jour du code

Retirer le paquet NuGet Scryber.Core
Installer le paquet NuGet IronPdf
Mettre à jour les imports de namespaces (using Scryber.Components; / Scryber.Drawing; / Scryber.PDF; → using IronPdf;)
Remplacer Document.ParseDocument(reader, "", ParseSourceType.DynamicContent) par renderer.RenderHtmlAsPdf(html)
Remplacer doc.SaveAsPDF(stream) par pdf.SaveAs(path) ou pdf.BinaryData
Convertir les modèles XHTML en HTML5 simple (aucune exigence de namespace)
Remplacer {{ }} liaison Handlebars par un templating standard (Razor / interpolation de chaîne)
Déplacer le CSS @page vers renderer.RenderingOptions (TaillePapier, MarginHaut, etc.)
Convertir les en-têtes/pieds de page de boîtes de marge @page en HtmlHeaderFooter avec {page} et {total-pages} espaces réservés
Ajouter l'initialisation de la licence au démarrage de l'application

Essai

Tester tous les modèles de documents
Vérifier la correspondance des styles (tirer pleinement parti de la prise en charge CSS)
Tester la liaison de données avec le nouveau modèle
Vérifier les sauts de page
Tester les en-têtes/pieds de page avec des espaces réservés pour les numéros de page
Comparaison des performances

Veuillez noter: Scryber est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à, approuvé par, ou sponsorisé par PerceiveIT Limited. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

...