Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. Migração de scryber.core para ironpdf
GUIAS DE MIGRAçãO

Como migrar do Scryber.Core para o IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

A migração do Scryber.Core para o IronPDF transforma seu fluxo de trabalho de geração de PDFs, passando de um mecanismo de análise XML/HTML personalizado para um renderizador moderno baseado no Chromium, com suporte completo a CSS3 e JavaScript . Este guia fornece um caminho de migração completo, passo a passo, que elimina preocupações com a licença LGPL, sintaxe de modelos proprietários e capacidades de renderização limitadas.

Por que migrar do Scryber.Core para o IronPDF?

Entendendo o Scryber.Core

Scryber.Core é uma biblioteca de código aberto que transforma modelos HTML em PDFs usando C#. Essa funcionalidade torna a ferramenta atraente para desenvolvedores familiarizados com desenvolvimento web e HTML. Diferentemente de outras soluções de PDF que exigem habilidades específicas de codificação de documentos, o Scryber.Core aproveita a versatilidade do HTML e os recursos de estilização do CSS para fornecer uma abordagem mais intuitiva para a geração de PDFs.

Embora o Scryber.Core seja uma opção viável para muitos desenvolvedores, principalmente devido ao seu alinhamento ideológico com os princípios do código aberto e à flexibilidade que oferece, ele não está isento de limitações.

Principais razões para migrar

  1. Preocupações com a licença LGPL: A licença LGPL exige que quaisquer modificações na própria biblioteca sejam de código aberto, o que pode ser limitante para algumas aplicações comerciais.
  2. Sintaxe de modelo personalizada: a sintaxe de vinculação proprietária requer uma curva de aprendizado
  3. Suporte limitado a CSS: Não é um renderizador totalmente baseado em navegador.
  4. Comunidade menor: Menos documentação e exemplos da comunidade.
  5. Sem execução de JavaScript : somente renderização estática
  6. Configuração complexa: abordagem de configuração com uso intensivo de XML
  7. Suporte comercial limitado: Scryber.Core é financiado principalmente pela comunidade.

Comparação entre Scryber.Core e IronPDF

Aspecto Scryber.Core IronPDF
Licença LGPL (restritiva) Comercial
Motor de renderização Personalizado Cromo
Suporte a CSS Limitado CSS3 completo
JavaScript Não ES2024 completo
Encadernação de modelo XML proprietário Padrão (Razor, etc.)
Curva de Aprendizagem Sintaxe personalizada HTML/CSS padrão
Suporte assíncrono Limitado Completo
Documentação Básico Extenso
Apoio comunitário Menor Grande
Suporte comercial Limitado Suporte profissional incluído

O IronPDF oferece suporte comercial de nível empresarial, documentação extensa e uma comunidade maior em comparação com o Scryber.Core. A biblioteca oferece opções de licenciamento mais flexíveis, sem as restrições da LGPL, tornando-a ideal para aplicações comerciais.

Para equipes que planejam adotar o .NET 10 e o C# 14 até 2025 e 2026, o moderno mecanismo Cromo do IronPDF oferece total compatibilidade com os padrões da web contemporâneos.

Antes de começar

Pré-requisitos

  1. Ambiente .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Acesso ao NuGet : Capacidade de instalar pacotes NuGet.
  3. Licença do IronPDF : Obtenha sua chave de licença em IronPDF

Alterações no pacote 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

Configuração de licença

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

Referência completa da API

Alterações de namespace

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

Mapeamentos da API principal

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 ou pdf.BinaryData
doc.Info.Title pdf.MetaData.Title
doc.Info.Author pdf.MetaData.Author
PDFPage pdf.Pages[i]
PDFLayoutDocument RenderingOptions
PDFStyle CSS em HTML
doc.RenderOptions.PaperSize RenderingOptions.PaperSize
Vinculação de dados ({{value}}) Razor/ Interpolação de strings

Exemplos de migração de código

Exemplo 1: Conversão básica de HTML para 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

Apó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 exemplo demonstra a diferença arquitetônica fundamental. Scryber.Core usa Document.ParseDocument() com um parâmetro ParseSourceType.DynamicContent para analisar conteúdo HTML, exigindo um bloco using para descarte adequado. O documento é então salvo com SaveAsPDF().

IronPDF usa uma instância de ChromePdfRenderer com RenderHtmlAsPdf() para renderizar HTML diretamente. O PDF foi salvo com SaveAs(). Não é necessário descarte manual — o IronPDF cuida da limpeza automaticamente. Consulte a documentação de conversão de HTML para PDF para obter exemplos completos.

Exemplo 2: Conversão de URL para 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

Apó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

O Scryber.Core não consegue converter URLs diretamente para PDF. Você deve buscar manualmente o conteúdo HTML usando HttpClient.GetStringAsync() e, em seguida, analisar o HTML baixado com Document.ParseDocument(). Essa abordagem não permite a execução de JavaScript , conteúdo dinâmico e a resolução adequada de CSS, pois o analisador personalizado não executa scripts.

O método RenderUrlAsPdf() do IronPDF lida com todo o processo em uma única chamada, incluindo a execução completa de JavaScript e a renderização de CSS com seu mecanismo Chromium. Saiba mais em nossos tutoriais .

Exemplo 3: Configurações de página personalizadas e margens

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

Apó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

O Scryber.Core usa doc.RenderOptions para configurar as opções de saída, como Compression (definido para OutputCompressionType.FlateDecode) e PaperSize (definido para PaperSize.A4), após analisar o documento.

IronPDF usa RenderingOptions no renderizador antes da renderização. As propriedades incluem PaperSize (definido como PdfPaperSize.A4), MarginTop e MarginBottom, definidos em milímetros. A principal diferença é que o IronPDF oferece controle direto de margens por meio de propriedades numéricas, enquanto o Scryber.Core usa estilos baseados em XML.

Padrões de Migração de Modelos

Migração de vinculação proprietária para modelos padrão

O Scryber.Core utiliza uma sintaxe de vinculação proprietária baseada em XML que precisa ser convertida para modelos padrão:

Vinculação do 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 com interpolação de strings em 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

A principal vantagem: o IronPDF usa C# e HTML padrão, então você pode usar qualquer mecanismo de templates (Razor, Handlebars, etc.) em vez de aprender uma sintaxe proprietária.

Migração de cabeçalhos e rodapés

Scryber.Core (cabeçalho/rodapé baseado em 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 (cabeçalhos/rodapés 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

O Scryber.Core requer uma definição de cabeçalho/rodapé baseada em XML com marcadores proprietários como {{pagenum}} e {{pagetotal}}. O IronPDF utiliza HTML/CSS completo para cabeçalhos e rodapés com marcadores de posição {page} e {total-pages}.

Novas funcionalidades após a migração

Após migrar para o IronPDF, você obtém recursos que o Scryber.Core não pode fornecer:

Fusão de PDFs

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

Segurança e metadados

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

Resumo da comparação de recursos

Recurso Scryber.Core IronPDF
HTML para PDF Básico Cromo completo
URL para PDF Busca manual Suporte nativo
Grade CSS Limitado Apoiado
Flexbox Limitado Apoiado
JavaScript Não ES2024 completo
Vinculação de dados XML proprietário Use Razor/Guidão
Cabeçalhos/Rodapés baseado em XML HTML/CSS
Mesclar PDFs Limitado Embutido
Dividir PDFs Não Sim
Marcas d'água Básico HTML completo
Assinaturas digitais Não Sim
PDF/A Não Sim
Proteção por senha Básico Completo
Suporte assíncrono Limitado Completo
Multiplataforma Sim Sim

Lista de verificação para migração

Pré-migração

  • Auditar todos os modelos do Scryber em busca de padrões XML/de vinculação.
  • Padrões de vinculação de dados do documento usados ​​({{model.Property}})
  • Identificar estilos personalizados que precisam de conversão para CSS.
  • Obtenha a chave de licença do IronPDF em IronPDF

Atualizações de código

  • Remover o pacote NuGet Scryber.Core
  • Instale o pacote NuGet IronPdf
  • Atualizar importações de namespace (using Scryber.Core; → using IronPdf;)
  • Substitua Document.ParseDocument(html, ParseSourceType.DynamicContent) por renderer.RenderHtmlAsPdf(html)
  • Substitua doc.SaveAsPDF() por pdf.SaveAs()
  • Converter modelos XML em HTML
  • Substituir vinculação proprietária por modelos padrão (Razor/interpolação de strings)
  • Atualizar configurações da página: doc.RenderOptions.PaperSize → renderer.RenderingOptions.PaperSize
  • Converter cabeçalhos/rodapés para formato HTML com os marcadores {page} e {total-pages}
  • Adicionar inicialização de licença na inicialização do aplicativo

Testando

  • Testar todos os modelos de documento
  • Verificar se os estilos correspondem (aproveitar ao máximo o suporte a CSS)
  • Testar a vinculação de dados com novos modelos
  • Verificar quebras de página
  • Testar cabeçalhos/rodapés com marcadores de posição para números de página
  • Comparação de desempenho
Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim