VIDEOS

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

Aktualisiert:19. Juli 2026

Der Wechsel von Scryber.Core zu IronPDF verlagert den PDF-Erstellungsablauf von einer benutzerdefinierten XHTML+CSS-Layout-Engine zu einem Chromium-basierten Renderer mit vollständigem CSS3- und JavaScript-Support. Diese Anleitung bietet einen schrittweisen Migrationspfad, der die Lizenzierungsüberlegungen zu LGPL v3, Scrybers XHTML-strengem Vorlagenmodell und die Renderunterschiede zwischen den beiden Engines abdeckt.

Warum von Scryber.Core zu IronPDF migrieren

Scryber.Core kennenlernen

Scryber.Core (gepflegt von Richard Hewitson, aktuelle Version 9.3.1) ist eine Open-Source-Bibliothek, die XHTML+CSS-Vorlagen mit ihrer eigenen Layout-Engine analysiert — kein Browser. Es unterstützt CSS-Styling, Handlebars-ähnliche {{ }} Datenbindung über doc.Params und SVG, wodurch es für Entwickler attraktiv ist, die PDF-Dokumente ohne Browserabhängigkeit HTML-gesteuert erstellen möchten.

Obwohl Scryber.Core eine brauchbare Option für HTML-Vorlagen-basierte PDF-Erstellung ist, zwingen mehrere Einschränkungen Teams zur Migration.

Wichtige Gründe für die Migration

LGPL v3 Lizenzprobleme: Offenlegungspflichten für den Quellcode gelten, wenn Sie Scryber selbst modifizieren; statische Verknüpfung in geschlossenen Anwendungen ist erlaubt, aber die Bedingungen schränken dennoch ein, wie Sie Änderungen ausliefern.
XHTML-strikt Eingabemodus: Vorlagen müssen gültiges XML sein — die meisten HTMLs aus der realen Welt erfordern eine Bereinigung, bevor Scryber sie analysiert.
Nicht-Browser-Renderer: Eine benutzerdefinierte XHTML/CSS-Layout-Engine — modernes CSS (Grid, vollständiges Flexbox, Container-Abfragen) und jeglicher JavaScriptwerden nicht ausgeführt.
Kleinere Gemeinschaft: Weniger bearbeitete Beispiele als in Mainstream-Bibliotheken.
Keine JavaScript-Ausführung: Nur statisches Rendering — Diagramme, SPAs und dynamische Widgets müssen vorgerendert werden.
Kein nativer URL-zu-PDF: Sie müssen HTML selbst abrufen (z.B. mit HttpClient) und es einfügen.
Gemeinschaftsunterstützt: Kommerzielle Unterstützungsmöglichkeiten sind begrenzt.

Vergleich zwischen Scryber.Core und IronPDF

Aspekt	Scryber.Core	IronPDF
Lizenz	LGPL v3	Kommerziell
Rendering-Engine	Benutzerdefinierte XHTML/CSS-Layout-Engine	Chromium
CSS-Unterstützung	Teilmenge (kein Grid, teilweises Flexbox)	Vollständig CSS3
JavaScript	Nicht ausgeführt	Vollständig (Chromium V8)
Vorlage Bindung	Handlebars-ähnliche `{{ }}` + `<template>`	Standard (Razor, RazorLight, etc.)
Eingabestriktheit	Erfordert wohlgeformtes XHTML	Akzeptiert HTML aus der realen Welt
Async-Unterstützung	`PDFAsync` MVC-Hilfe; sync core	Volle Async-API
Dokumentation	Read-the-docs-Website + Beispiele	Umfangreiche
Community-Unterstützung	Kleiner	Größer
Kommerzielle Unterstützung	Gemeinschaftsunterstützt	Kommerzieller Support verfügbar

IronPDF bietet kommerziellen Support, Dokumentation und eine größere Benutzerbasis im Vergleich zu Scryber.Core. Die Bibliothek ist für kommerzielle Nutzung ohne LGPL-Verpflichtungen lizenziert.

Bevor Sie beginnen

Voraussetzungen

.NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# 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

Lizenz-Konfiguration

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

Komplette API-Referenz

Namensraumänderungen

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

Kern-API-Zuordnungen

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 in Vorlage	`renderer.RenderingOptions.PaperSize` / Ränder
`doc.RenderOptions`	`renderer.RenderingOptions`
Handlebars `{{value}}` + `doc.Params`	Razor / Zeichenfolgeninterpolation

Beispiele für die Code-Migration

Beispiel 1: Einfache Konvertierung von HTML in PDF

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

Nach (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 umschließt den XHTML-String in einem StringReader, gibt ihn an Document.ParseDocument mit ParseSourceType.DynamicContent weiter und schreibt das PDF über SaveAsPDF in ein FileStream. Die XHTML-Namensraumdeklaration ist erforderlich — Scryber lehnt HTML ab, das kein wohlgeformtes XML ist.

IronPDF verwendet eine ChromePdfRenderer Instanz mit RenderHtmlAsPdf(), um HTML direkt zu rendern, und speichert mit SaveAs(). HTML5 aus der realen Welt wird unverändert akzeptiert. Siehe die HTML-zu-PDF-Dokumentation für weitere Beispiele.

Beispiel 2: Konvertierung von URL in PDF

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

Nach (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 hat keinen nativen URL-zu-PDF-Einstiegspunkt. Sie holen das HTML selbst mit HttpClient.GetStringAsync() und geben es in Document.ParseDocument() ein. Da Scryber wohlgeformtes XHTML erfordert, werden die meisten Live-Seiten eine Bereinigung (zum Beispiel über HtmlAgilityPack) benötigen, bevor sie analysiert werden. JavaScriptwird nicht ausgeführt, sodass dynamisch gerenderte Inhalte fehlen werden.

IronPDFs RenderUrlAsPdf() verarbeitet Abrufen, JavaScript-Ausführung und CSS-Rendering in einem einzigen Aufruf über seine Chromium-Engine. Erfahren Sie mehr in unseren Anleitungen.

Beispiel 3: Benutzerdefinierte Seiteneinstellungen und Ränder

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

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

In Scryber.Core werden die Seitengröße und Ränder in der Vorlage über @page CSS deklariert, während doc.RenderOptions ausgabeseitige Einstellungen wie Kompression (OutputCompressionType.FlateDecode) bereitstellt.

IronPDF verschiebt die Seitengeometrie zu RenderingOptions auf dem Renderer: PaperSize (eingestellt auf PdfPaperSize.A4), MarginTop und MarginBottom in Millimetern. Die Seitengeometrie liegt auf der API-Oberfläche anstatt innerhalb der Vorlage.

Migrationsmuster für Vorlagen

Scryber-Bindung auf Standardvorlagen migrieren

Scryber.Core verwendet XHTML mit Handlebars-ähnlichen {{ }} Bindungen (gelöst über doc.Params) und einem <template data-bind='...'> Konstrukt für sich wiederholende Abschnitte. Um zu migrieren, drücken Sie diese in der Standard-.NET-Vorlagenerstellung aus:

Scryber Binding (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 mit C# String-Interpolation:

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

Da IronPDF reines HTML akzeptiert, können Sie jede .NET-Templating-Engine verwenden – Razor, RazorLight, Handlebars.Net – anstelle von Scrybers {{ }} + <template> Konstrukten.

Kopf- und Fußzeilen-Migration

Scryber.Core (XHTML + @page Randkästen):

<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 (HTML-Kopf-/Fußzeilen):

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 definiert Kopf- und Fußzeilen über @page Randkästen in CSS, unter Verwendung von counter(page) und counter(pages) für Seitennummern.IronPDF verwendet HtmlHeaderFooter mit vollem HTML/CSS für Kopf- und Fußzeilen und die Platzhalter {page} und {total-pages}.

Neue Funktionen nach der Migration

Nach der Umstellung auf IronPDF erhalten Sie Funktionen, die Scryber.Core nicht bieten kann:

PDF-Zusammenführung

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

Sicherheit und Metadaten

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

Zusammenfassung des Funktionsvergleichs

Feature	Scryber.Core	IronPDF
HTML zu PDF	XHTML+CSS über benutzerdefinierte Layout-Engine	Vollständiges Chromium
URL zu PDF	Nur manueller Abruf	Native `RenderUrlAsPdf`
CSS-Raster	Nicht unterstützt	Volle Unterstützung
Flexbox	Teilweise	Volle Unterstützung
JavaScript	Nicht ausgeführt	Vollständig (V8)
Datenbindung	`{{ }}` Handlebars + `doc.Params`	Razor / RazorLight / interpolation
Kopf-/Fußzeilen	`@page` Randkästen / Vorlagenabschnitte	`HtmlHeaderFooter` mit `{page}` `{total-pages}`
PDFs zusammenführen	Nicht unterstützt	Integrierte `PdfDocument.Merge`
PDFs teilen	Nicht unterstützt	Ja
Wasserzeichen	Überlagerung von HTML in Vorlage	Native `ApplyStamp` / `ApplyWatermark`
Digitale Signaturen	Nicht unterstützt	Ja
PDF/A	Nicht unterstützt	Ja (PDF/A-1b, PDF/A-3)
Passwortschutz	Nicht unterstützt	Vollständig (Benutzer/Inhaber + Berechtigungen)
Async-Unterstützung	`PDFAsync` MVC-Hilfe; sync core	Volle Async-Oberfläche
Plattformübergreifend	Ja (.NET Std 2.0/2.1, .NET 8/9/10)	Ja

Migrations-Checkliste

Vor der Migration

Alle Scryber-Vorlagen auf XHTML/Bindungsmuster überprüfen
Verwendete Dokumentendatenbindungsmuster ({{model.Property}})
Identifizieren Sie benutzerdefinierte Stile, die eine CSS-Konvertierung benötigen.
Den IronPDF Lizenzschlüssel erhalten Sie unter IronPDF

Code-Aktualisierungen

Entfernen Sie das Scryber.Core NuGet-Paket
Installieren Sie das IronPdf NuGet-Paket
Aktualisieren Sie die Namensraumimporte (using Scryber.Components; / Scryber.Drawing; / Scryber.PDF; → using IronPdf;)
Ersetzen Sie Document.ParseDocument(reader, "", ParseSourceType.DynamicContent) durch renderer.RenderHtmlAsPdf(html)
Ersetzen Sie doc.SaveAsPDF(stream) durch pdf.SaveAs(path) oder pdf.BinaryData
Konvertieren Sie XHTML-Vorlagen in einfaches HTML5 (keine Namensraumerforderlichkeit)
Ersetzen Sie {{ }} Handlebars-Bindung durch standardmäßige Templating (Razor / String-Interpolation)
Verschieben Sie @page CSS zu renderer.RenderingOptions (Papiergröße, Oberer Rand usw.)
Konvertieren Sie @page Randkästen-Kopfzeilen/-fußzeilen zu HtmlHeaderFooter mit {page} und {total-pages} Platzhaltern
Lizenzinitialisierung beim Anwendungsstart hinzufügen

Testen

Alle Dokumentvorlagen testen
Stilübereinstimmungen überprüfen (volle CSS-Unterstützung nutzen)
Test der Datenbindung mit neuer Vorlagenstruktur
Seitenumbrüche überprüfen
Testen Sie Kopf- und Fußzeilen mit Platzhaltern für Seitenzahlen
Leistungsvergleich

Hinweis:Scryber ist ein eingetragenes Warenzeichen des jeweiligen Eigentümers. Diese Seite ist weder mit PerceiveIT Limited verbunden, noch von ihr unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

Warum von Scryber.Core zu IronPDF migrieren

Scryber.Core kennenlernen

Wichtige Gründe für die Migration

Vergleich zwischen Scryber.Core und IronPDF

Bevor Sie beginnen

Voraussetzungen

NuGet-Paketänderungen

Lizenz-Konfiguration

Komplette API-Referenz

Namensraumänderungen

Kern-API-Zuordnungen

Beispiele für die Code-Migration

Beispiel 1: Einfache Konvertierung von HTML in PDF

Beispiel 2: Konvertierung von URL in PDF

Beispiel 3: Benutzerdefinierte Seiteneinstellungen und Ränder

Migrationsmuster für Vorlagen

Scryber-Bindung auf Standardvorlagen migrieren

Kopf- und Fußzeilen-Migration

Neue Funktionen nach der Migration

PDF-Zusammenführung

Sicherheit und Metadaten

Zusammenfassung des Funktionsvergleichs

Migrations-Checkliste

Vor der Migration

Code-Aktualisierungen

Testen

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Iron-Support-Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

Warum von Scryber.Core zu IronPDF migrieren

Scryber.Core kennenlernen

Wichtige Gründe für die Migration

Vergleich zwischen Scryber.Core und IronPDF

Bevor Sie beginnen

Voraussetzungen

NuGet-Paketänderungen

Lizenz-Konfiguration

Komplette API-Referenz

Namensraumänderungen

Kern-API-Zuordnungen

Beispiele für die Code-Migration

Beispiel 1: Einfache Konvertierung von HTML in PDF

Beispiel 2: Konvertierung von URL in PDF

Beispiel 3: Benutzerdefinierte Seiteneinstellungen und Ränder

Migrationsmuster für Vorlagen

Scryber-Bindung auf Standardvorlagen migrieren

Kopf- und Fußzeilen-Migration

Neue Funktionen nach der Migration

PDF-Zusammenführung

Sicherheit und Metadaten

Zusammenfassung des Funktionsvergleichs

Migrations-Checkliste

Vor der Migration

Code-Aktualisierungen

Testen

Verwandte Artikel

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Wie man XML in PDF mit C# konvertiert

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Thank You

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Möchten Sie IronSuite KOSTENLOS in einem Live-Projekt einsetzen?

DLL-Download

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Von Millionen von Ingenieur*innen weltweit vertraut

Iron-Support-Team