Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von scryber.core zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von Scryber.Core zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Durch die Migration von Scryber.Core zu IronPDF wird Ihr PDF-Generierungs-Workflow von einer benutzerdefinierten XML/HTML-Parsing-Engine auf einen modernen Chromium-basierten Renderer mit vollständiger CSS3- und JavaScript-Unterstützung umgestellt. Dieser Leitfaden bietet einen vollständigen, schrittweisen Migrationspfad, der Bedenken hinsichtlich der LGPL-Lizenzierung, der proprietären Vorlagensyntax und der begrenzten Rendering-Funktionen ausräumt.

Warum von Scryber.Core zu IronPDF migrieren

Scryber.Core kennenlernen

Scryber.Core ist eine Open-Source-Bibliothek, die HTML-Vorlagen mit C# in PDFs umwandelt. Diese Fähigkeit macht es zu einem attraktiven Werkzeug für Entwickler, die mit Webentwicklung und HTML vertraut sind. Im Gegensatz zu anderen PDF-Lösungen, die spezielle Kenntnisse in der Dokumentenkodierung erfordern, nutzt Scryber.Core die Vielseitigkeit von HTML und die CSS-Styling-Funktionen, um einen intuitiveren Ansatz für die PDF-Generierung zu bieten.

Obwohl Scryber.Core für viele Entwickler vor allem aufgrund seiner ideologischen Ausrichtung auf Open-Source-Prinzipien und der Flexibilität, die es bietet, eine praktikable Option ist, ist es nicht ohne Einschränkungen.

Wichtige Gründe für die Migration

  1. Bedenken hinsichtlich der LGPL-Lizenz: Die LGPL-Lizenz verlangt, dass alle Änderungen an der Bibliothek selbst als Open Source veröffentlicht werden müssen, was für einige kommerzielle Anwendungen einschränkend wirken kann.
  2. Benutzerdefinierte Vorlagensyntax: Die proprietäre Bindungssyntax erfordert einen gewissen Lernaufwand.
  3. Eingeschränkte CSS-Unterstützung: Kein vollständiger browserbasierter Renderer
  4. Kleinere Community: Weniger Dokumentation und Community-Beispiele
  5. Keine JavaScript-Ausführung: Nur statisches Rendering
  6. Komplexe Konfiguration: XML-lastiger Konfigurationsansatz
  7. Eingeschränkter kommerzieller Support: Scryber.Core wird in erster Linie von der Community unterstützt.

Vergleich zwischen Scryber.Core und IronPDF

Aspekt Scryber.Core IronPDF
Lizenz LGPL (restriktiv) Kommerziell
Rendering-Engine Benutzerdefiniert Chromium
CSS-Unterstützung Beschränkt Vollständig CSS3
JavaScript Nein Vollständiger ES2024
Vorlage Bindung Proprietäres XML Standard (Razor, etc.)
Lernkurve Benutzerdefinierte Syntax Standard HTML/CSS
Async-Unterstützung Beschränkt Voll
Dokumentation Basic Umfangreiche
Community-Unterstützung Kleiner Groß
Kommerzielle Unterstützung Beschränkt Professionelle Unterstützung inklusive

IronPDF bietet im Vergleich zu Scryber.Core kommerziellen Support für Unternehmen, eine umfangreiche Dokumentation und eine größere Community. Die Bibliothek bietet flexiblere Lizenzierungsoptionen ohne LGPL-Beschränkungen, was sie ideal für kommerzielle Anwendungen macht.

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet die moderne Chromium-Engine von IronPDF volle Kompatibilität mit den aktuellen Webstandards.

Bevor Sie beginnen

Voraussetzungen

  1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
  3. 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;
using Scryber.Components.Pdf;
using Scryber.PDF;
using Scryber.Styles;
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
// Before: Scryber.Core
using Scryber.Components;
using Scryber.Components.Pdf;
using Scryber.PDF;
using Scryber.Styles;
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
Imports Scryber.Components
Imports Scryber.Components.Pdf
Imports Scryber.PDF
Imports Scryber.Styles
Imports Scryber.Core
Imports Scryber.Core.Html
Imports Scryber.Drawing

Imports IronPdf
Imports IronPdf.Rendering
$vbLabelText   $csharpLabel

Kern-API-Zuordnungen

Scryber.Core IronPDF
Document.ParseDocument(html) renderer.RenderHtmlAsPdf(html)
Document.ParseTemplate(path) renderer.RenderHtmlFileAsPdf(path)
doc.SaveAsPDF(path) pdf.SaveAs(path)
doc.SaveAsPDF(stream) pdf.Stream oder pdf.BinaryData
doc.Info.Title pdf.MetaData.Title
doc.Info.Author pdf.MetaData.Author
PDFPage pdf.Pages[i]
PDFLayoutDocument RenderingOptions
PDFStyle CSS in HTML
doc.RenderOptions.PaperSize RenderingOptions.PaperSize
Datenbindung ({{value}}) Razor/String-Interpolation

Beispiele für die Code-Migration

Beispiel 1: Einfache Konvertierung von HTML in PDF

Vor (Scryber.Core):

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

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

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

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

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

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

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

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

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

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

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

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

Dieses Beispiel verdeutlicht den grundlegenden architektonischen Unterschied. Scryber.Core verwendet Document.ParseDocument() mit einem ParseSourceType.DynamicContent Parameter zum Parsen von HTML-Inhalten, was einen using Block für die ordnungsgemäße Entsorgung erfordert. Das Dokument wird dann mit SaveAsPDF() gespeichert.

IronPDF verwendet eine ChromePdfRenderer Instanz mit RenderHtmlAsPdf(), um HTML direkt zu rendern. Die PDF-Datei wurde unter SaveAs() gespeichert. Eine manuelle Entsorgung ist nicht erforderlich - IronPDF übernimmt die Bereinigung automatisch. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (Scryber.Core):

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

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

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

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

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

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

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

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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

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

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

Scryber.Core kann URLs nicht direkt in PDF konvertieren. Sie müssen den HTML-Inhalt manuell mit HttpClient.GetStringAsync() abrufen und anschließend den heruntergeladenen HTML-Code mit Document.ParseDocument() analysieren. Bei diesem Ansatz fehlen die Ausführung von JavaScript, dynamische Inhalte und die richtige CSS-Auflösung, da der benutzerdefinierte Parser keine Skripte ausführt.

Die Methode RenderUrlAsPdf() von IronPDF erledigt den gesamten Prozess in einem einzigen Aufruf, einschließlich der vollständigen JavaScript-Ausführung und des CSS-Renderings mit der Chromium-Engine. Weitere Informationen finden Sie in unseren Tutorials .

Beispiel 3: Benutzerdefinierte Seiteneinstellungen und Ränder

Vor (Scryber.Core):

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

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

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

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

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

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

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

Nach (IronPDF):

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

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

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

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

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

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

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

Scryber.Core verwendet doc.RenderOptions, um Ausgabeeinstellungen wie Compression (auf OutputCompressionType.FlateDecode gesetzt) ​​und PaperSize (auf PaperSize.A4 gesetzt) ​​nach dem Parsen des Dokuments zu konfigurieren.

IronPDF verwendet RenderingOptions auf dem Renderer vor dem Rendern. Zu den Eigenschaften gehören PaperSize (eingestellt auf PdfPaperSize.A4), MarginTop und MarginBottom, jeweils in Millimetern angegeben. Der Hauptunterschied besteht darin, dass IronPDF eine direkte Randsteuerung über numerische Eigenschaften bietet, während Scryber.Core XML-basiertes Styling verwendet.

Migrationsmuster für Vorlagen

Migration proprietärer Bindungen zu Standardvorlagen

Scryber.Core verwendet eine proprietäre XML-basierte Bindungssyntax, die in ein Standard-Templating konvertiert werden muss:

Scryber.Core-Bindung:

<pdf:Para text='{{model.Name}}' />
<pdf:Para text='Total: {{model.Total:C}}' />
<pdf:ForEach on='{{model.Items}}'>
    <pdf:Para text='{{.Name}}: {{.Price}}' />
</pdf:ForEach>
<pdf:Para text='{{model.Name}}' />
<pdf:Para text='Total: {{model.Total:C}}' />
<pdf:ForEach on='{{model.Items}}'>
    <pdf:Para text='{{.Name}}: {{.Price}}' />
</pdf:ForEach>
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

Der entscheidende Vorteil: IronPDF verwendet Standard-C# und -HTML, so dass Sie eine beliebige Template-Engine (Razor, Handlebars usw.) verwenden können und keine proprietäre Syntax lernen müssen.

Kopf- und Fußzeilen-Migration

Scryber.Core (XML-basierte Kopf-/Fußzeile):

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

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 benötigt eine XML-basierte Header-/Footer-Definition mit proprietären Platzhaltern wie {{pagenum}} und {{pagetotal}}. IronPDF verwendet vollständiges HTML/CSS für Kopf- und Fußzeilen mit den Platzhaltern {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 Basic Vollständiges Chromium
URL zu PDF Manuell abrufen Native Unterstützung
CSS-Raster Beschränkt Unterstützt
Flexbox Beschränkt Unterstützt
JavaScript Nein Vollständiger ES2024
Datenbindung Proprietäres XML Razor/Handlebars verwenden
Kopf-/Fußzeilen XML-basiert HTML/CSS
PDFs zusammenführen Beschränkt Eingebaut
PDFs teilen Nein Ja
Wasserzeichen Basic Vollständiges HTML
Digitale Signaturen Nein Ja
PDF/A Nein Ja
Passwortschutz Basic Voll
Async-Unterstützung Beschränkt Voll
Plattformübergreifend Ja Ja

Migrations-Checkliste

Vor der Migration

  • Alle Scryber-Vorlagen auf XML-/Bindungsmuster prüfen
  • Verwendete Dokumentdatenbindungsmuster ({{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 NuGet Paket Scryber.Core
  • Installieren Sie das NuGet Paket IronPdf
  • Namespace-Importe aktualisieren (using Scryber.Core; → using IronPdf;)
  • Ersetzen Sie Document.ParseDocument(html, ParseSourceType.DynamicContent) durch renderer.RenderHtmlAsPdf(html)
  • Ersetzen Sie doc.SaveAsPDF() durch pdf.SaveAs()
  • XML-Vorlagen in HTML konvertieren
  • Proprietäre Bindungen durch Standardvorlagen ersetzen (Razor/ String-Interpolation)
  • Seiteneinstellungen aktualisieren: doc.RenderOptions.PaperSize → renderer.RenderingOptions.PaperSize
  • Konvertieren Sie Kopf- und Fußzeilen in das HTML-Format mit den Platzhaltern {page} und {total-pages}
  • 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
Curtis Chau
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 ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an