Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. migración de scryber.core a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de Scryber.Core a IronPDF en C#

Curtis Chau
Curtis Chau
Actualizado:

La migración de Scryber.Core aIronPDFtransforma el flujo de trabajo de generación de PDF de un motor de análisis XML/HTML personalizado a un moderno renderizador basado en Chromium con compatibilidad total con CSS3 y JavaScript. Esta guía proporciona una ruta de migración completa, paso a paso, que elimina los problemas de licencia LGPL, la sintaxis de plantilla propietaria y las capacidades de renderizado limitadas.

Por qué migrar de Scryber.Core a IronPDF

Entendiendo Scryber.Core

Scryber.Core es una biblioteca de código abierto que transforma plantillas HTML en PDF utilizando C#. Esta capacidad lo convierte en una herramienta atractiva para desarrolladores familiarizados con el desarrollo web y HTML. A diferencia de otras soluciones PDF que requieren conocimientos específicos de codificación de documentos, Scryber.Core aprovecha la versatilidad de HTML y las capacidades de estilo CSS para ofrecer un enfoque de generación de PDF más intuitivo.

Aunque Scryber.Core es una opción viable para muchos desarrolladores, principalmente debido a su alineación ideológica con los principios del código abierto y la flexibilidad que ofrece, no está exento de limitaciones.

Razones clave para migrar

  1. Preocupaciones sobre la licencia LGPL: La licencia LGPL exige que cualquier modificación a la biblioteca en sí sea de código abierto, lo que puede ser limitante para algunas aplicaciones comerciales.
  2. Sintaxis de plantilla personalizada: La sintaxis de enlace propietaria requiere una curva de aprendizaje.
  3. Compatibilidad limitada con CSS: no es un renderizador completo basado en navegador.
  4. Comunidad más pequeña: menos documentación y ejemplos comunitarios
  5. Sin ejecución de JavaScript: solo representación estática
  6. Configuración compleja: enfoque de configuración basado en XML
  7. Soporte comercial limitado: Scryber.Core cuenta principalmente con soporte de la comunidad.

Comparación entre Scryber.Core e IronPDF

Aspecto Scryber.Core IronPDF
Licencia LGPL (restrictiva) Comercial
Motor de renderizado A medida Chromium
Soporte CSS Limitado CSS3 completo
JavaScript No ES2024 completo
Vinculación de plantillas XML propietario Estándar (Razor, etc.)
Curva de aprendizaje Sintaxis personalizada HTML/CSSestándar
Soporte de Async Limitado Completo
Documentación Básico Amplia
Apoyo a la comunidad Más pequeño Sitio web de gran tamaño
Soporte comercial Limitado Asistencia profesional incluida

IronPDF ofrece soporte comercial de nivel empresarial, amplia documentación y una comunidad más grande en comparación con Scryber.Core. La biblioteca ofrece opciones de licencia más flexibles sin restricciones LGPL, lo que la hace ideal para aplicaciones comerciales.

Para los equipos que planean la adopción de .NET 10 y C# 14 hasta 2025 y 2026, el moderno motor Chromium de IronPDFproporciona compatibilidad total con los estándares web contemporáneos.

Antes de empezar

Prerrequisitos

  1. Entorno .NET : .NET Framework 4.6.2+ o .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Acceso a NuGet : Capacidad para instalar paquetes NuGet
  3. Licencia deIronPDF: Obtenga su clave de licencia en IronPDF

Cambios en el paquete 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

Configuración de licencias

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

Referencia completa de la API

Cambios en el espacio de nombres

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

Mapeos de API principales

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 o pdf.BinaryData
doc.Info.Title pdf.MetaData.Title
doc.Info.Author pdf.MetaData.Author
PDFPage pdf.Pages[i]
PDFLayoutDocument RenderingOptions
PDFStyle CSS en HTML
doc.RenderOptions.PaperSize RenderingOptions.PaperSize
Enlace de datos ({{value}}) Interpolación Razor/String

Ejemplos de migración de código

Ejemplo 1: Conversión básica de HTML a PDF

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

Después (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

Este ejemplo demuestra la diferencia arquitectónica fundamental. Scryber.Core utiliza Document.ParseDocument() con un parámetro ParseSourceType.DynamicContent para analizar contenido HTML, lo que requiere un bloque using para su eliminación adecuada. Luego, el documento se guarda con SaveAsPDF().

IronPDF utiliza una instancia ChromePdfRenderer con RenderHtmlAsPdf() para representar HTML directamente. El PDF se guarda con SaveAs(). No es necesaria la eliminación manual:IronPDFse encarga de la limpieza automáticamente. Consulte la documentación HTML a PDF para ver ejemplos completos.

Ejemplo 2: Conversión de URL a PDF

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

Después (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 no puede convertir directamente URL a PDF. Debes obtener manualmente el contenido HTML usando HttpClient.GetStringAsync() y luego analizar el HTML descargado con Document.ParseDocument(). Este enfoque no tiene en cuenta la ejecución de JavaScript, el contenido dinámico y la resolución adecuada de CSS porque el analizador personalizado no ejecuta secuencias de comandos.

El método RenderUrlAsPdf() deIronPDFgestiona todo el proceso en una sola llamada, incluyendo la ejecución completa de JavaScripty la renderización de CSS con su motor Chromium. Obtenga más información en nuestros tutoriales .

Ejemplo 3: Configuración de página personalizada y márgenes

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

Después (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 usa doc.RenderOptions para configurar ajustes de salida como Compression (establecido en OutputCompressionType.FlateDecode) y PaperSize (establecido en PaperSize.A4) después de analizar el documento.

IronPDF utiliza RenderingOptions en el renderizador antes de renderizar. Las propiedades incluyen PaperSize (establecido en PdfPaperSize.A4), MarginTop y MarginBottom establecido en milímetros. La diferencia clave es queIronPDFproporciona un control directo de los márgenes mediante propiedades numéricas, mientras que Scryber.Core utiliza estilos basados en XML.

Patrones de migración de plantillas

Migración de enlaces propietarios a plantillas estándar

Scryber.Core utiliza una sintaxis propia de vinculación basada en XML que debe convertirse a plantillas estándar:

Enlace de Scryber.Core:

<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 con interpolación de cadenas 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)
$vbLabelText   $csharpLabel

La ventaja clave:IronPDFutiliza C# y HTML estándar, por lo que se puede utilizar cualquier motor de plantillas (Razor, Handlebars, etc.) en lugar de aprender sintaxis propietaria.

Migración de encabezados y pies de página

Scryber.Core (encabezado/pie basado en XML):

<?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 (encabezados/pies de página HTML):

using IronPdf;

var renderer = new ChromePdfRenderer();

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

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

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

var renderer = new ChromePdfRenderer();

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

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

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

Dim renderer As New ChromePdfRenderer()

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

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

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

Scryber.Core requiere una definición de encabezado/pie de página basada en XML con marcadores de posición propietarios como {{pagenum}} y {{pagetotal}}.IronPDFutiliza HTML/CSScompleto para encabezados y pies de página con marcadores de posición {page} y {total-pages}.

Nuevas capacidades tras la migración

Tras migrar a IronPDF, obtendrá funciones que Scryber.Core no puede ofrecer:

Fusión de PDF

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

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

var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("complete_book.pdf");
Dim pdf1 = PdfDocument.FromFile("chapter1.pdf")
Dim pdf2 = PdfDocument.FromFile("chapter2.pdf")
Dim pdf3 = PdfDocument.FromFile("chapter3.pdf")

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

Seguridad y metadatos

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

Resumen comparativo de características

Característica Scryber.Core IronPDF
HTML a PDF Básico Chromium completo
URL a PDF Búsqueda manual Soporte nativo
CSS Grid Limitado Se admite
Flexbox Limitado Se admite
JavaScript No ES2024 completo
Vinculación de datos XML propietario Utilizar Razor/Handlebars
Encabezados/pies de página Basado en XML HTML/CSS
Fusionar PDF Limitado Incorporado en
Dividir PDF No Sí
Marcas de agua Básico HTML completo
Firmas digitales No Sí
PDF/A No Sí
Protección por contraseña Básico Completo
Soporte de Async Limitado Completo
Multiplataforma Sí Sí

Lista de comprobación de la migración

Pre-Migración

  • Auditar todas las plantillas de Scryber en busca de patrones de enlace/XML
  • Patrones de enlace de datos de documentos utilizados ({{model.Property}})
  • Identificar estilos personalizados que necesitan conversión CSS
  • Obtenga la clave de licencia deIronPDFen IronPDF

Actualizaciones de código

  • Eliminar el paquete NuGet Scryber.Core
  • Instalar el paquete NuGet IronPdf
  • Actualizar las importaciones del espacio de nombres (using Scryber.Core; → using IronPdf;)
  • Reemplace Document.ParseDocument(html, ParseSourceType.DynamicContent) con renderer.RenderHtmlAsPdf(html)
  • Reemplace doc.SaveAsPDF() con pdf.SaveAs()
  • Convertir plantillas XML a HTML
  • Reemplazar la vinculación propietaria con plantillas estándar (Razor/interpolación de cadenas)
  • Actualizar la configuración de la página: doc.RenderOptions.PaperSize → renderer.RenderingOptions.PaperSize
  • Convierte encabezados y pies de página a formato HTML con los marcadores de posición {page} y {total-pages}
  • Agregar inicialización de licencia al iniciar la aplicación

Pruebas

  • Probar todas las plantillas de documentos
  • Verificar coincidencias de estilo (aprovechar la compatibilidad total con CSS)
  • Pruebe el enlace de datos con nuevas plantillas
  • Verificación de los saltos de página
  • Pruebe encabezados y pies de página con marcadores de posición de número de página
  • Comparación de rendimiento
Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame