Como migrar do FastReport para o IronPDF em C#

Os desafios do FastReport

1. Dependência do Designer de Relatórios: A criação de layouts complexos exige um designer visual ou conhecimento profundo da estrutura de arquivos .frx — o que não é adequado para abordagens de desenvolvimento "code-first".

2. Curva de Aprendizagem Íngreme: A arquitetura baseada em bandas do Relatório Rápido (DataBand, PageHeaderBand, PageFooterBand) exige a compreensão de conceitos específicos do relatório que não são transferíveis para outras tecnologias.

3. Suporte limitado a CSS: o estilo padrão da Web não é suportado nativamente; A estilização é feita através do formato proprietário do FastReport, em vez do CSS convencional.

4. Vinculação de dados complexa: as conexões RegisterData() e DataSource adicionam código repetitivo para cenários simples de geração de PDF.

5. Pacotes fragmentados: Vários pacotes NuGet são necessários para a funcionalidade completa (FastReport.OpenSource, FastReport.OpenSource.Export.PdfSimple, etc.).

6. Complexidade do licenciamento: a versão de código aberto tem funcionalidades limitadas; É necessária a versão comercial para criptografia de PDF, assinatura digital e incorporação de fontes.

Comparação de arquitetura

Principais benefícios da migração

1. Tecnologias Web: Utilize HTML/CSS em vez de layouts proprietários baseados em bandas.
2. Desenvolvimento orientado a código: Gere PDFs programaticamente sem depender de um designer visual.
3. Pacote único: Um único pacote NuGet inclui todos os recursos de PDF.
4. Renderização moderna: o mais recente mecanismo Chromium para saída CSS3 com perfeição de pixels.
5. Manipulação completa de PDFs: mesclar, dividir, segurança, formulários — e não apenas exportar.

Pré-requisitos

Certifique-se de que seu ambiente atenda a estes requisitos:

• .NET Framework 4.6.2 ou superior ou .NET Core 3.1 / .NET 5-9
• Visual Studio 2019 ou superior ou VS Code com extensão C#
• Acesso ao Gerenciador de Pacotes NuGet
• Chave de licença do IronPDF (teste gratuito disponível em IronPDF )

Auditoria de uso do FastReport

Execute estes comandos no diretório da sua solução para identificar todas as referências ao FastReport:

# Find all Relatório Rápido references
grep -r "FastReport\|\.frx\|PDFExport\|PDFSimpleExport\|DataBand\|RegisterData" --include="*.cs" --include="*.csproj" .

# Check NuGet packages
dotnet list package | grep FastReport

# Find all Relatório Rápido references
grep -r "FastReport\|\.frx\|PDFExport\|PDFSimpleExport\|DataBand\|RegisterData" --include="*.cs" --include="*.csproj" .

# Check NuGet packages
dotnet list package | grep FastReport

Documente seus modelos de relatório

Antes da migração, catalogue todos os arquivos .frx e suas respectivas finalidades:

• Nome e finalidade do relatório
• Fontes de dados utilizadas Configuração de cabeçalhos/rodapés
• Requisitos de numeração de páginas Formatação ou estilo especiais

Entendendo a Mudança de Paradigma

A mudança mais significativa ao migrar do Relatório Rápido para o IronPDF é a abordagem de design fundamental. O Relatório Rápido usa um design visual baseado em bandas com arquivos de modelo .frx e conceitos proprietários como DataBand, PageHeaderBand e RegisterData(). O IronPDF utiliza HTML/CSS — tecnologias web que a maioria dos desenvolvedores já conhece.

Isso significa converter as configurações de banda do Relatório Rápido em modelos HTML, substituir RegisterData() por vinculação direta de dados via interpolação de strings ou modelos Razor e transformar PageHeaderBand/PageFooterBand em cabeçalhos e rodapés baseados em HTML.

Passo 1: Atualizar pacotes NuGet

Remova todos os pacotes Relatório Rápido e instale o IronPDF:

# Remove all Relatório Rápido packages
dotnet remove package FastReport.OpenSource
dotnet remove package FastReport.OpenSource.Export.PdfSimple
dotnet remove package FastReport.OpenSource.Web
dotnet remove package FastReport.OpenSource.Data.MsSql

# Install IronPDF (includes all features)
dotnet add package IronPdf

# Remove all Relatório Rápido packages
dotnet remove package FastReport.OpenSource
dotnet remove package FastReport.OpenSource.Export.PdfSimple
dotnet remove package FastReport.OpenSource.Web
dotnet remove package FastReport.OpenSource.Data.MsSql

# Install IronPDF (includes all features)
dotnet add package IronPdf

Etapa 2: Atualizar referências de namespace

Substitua os namespaces do Relatório Rápido pelo IronPDF:

// Remove these
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

// Add this
using IronPdf;

// Remove these
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

// Add this
using IronPdf;

Imports IronPdf

Etapa 3: Configurar a licença

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Mapeamento de Classes Principais

Mapeamento de Métodos

Conversão do marcador de posição do número da página

O Relatório Rápido e o IronPDF usam sintaxes diferentes para marcadores de posição de números de página:

Conversão de HTML para PDF

Este exemplo demonstra a diferença fundamental entre a abordagem HTMLObject do Relatório Rápido e a renderização direta do IronPDF.

Implementação do FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            // Create HTML object
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 500;
            htmlObject.Height = 300;
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>";

            // Prepare report
            report.Prepare();

            // Export to PDF
            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            // Create HTML object
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 500;
            htmlObject.Height = 300;
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>";

            // Prepare report
            report.Prepare();

            // Export to PDF
            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO

Class Program
    Shared Sub Main()
        Using report As New Report()
            ' Create HTML object
            Dim htmlObject As New FastReport.HTMLObject()
            htmlObject.Width = 500
            htmlObject.Height = 300
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>"

            ' Prepare report
            report.Prepare()

            ' Export to PDF
            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("output.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class

Implementação do IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

O Relatório Rápido exige a criação de um objeto Report, um objeto HTMLObject com dimensões fixas, a preparação do relatório e a exportação via fluxo — sete linhas de código com instruções using. O IronPDF consegue o mesmo resultado em três linhas com renderização HTML direta. Para mais opções, consulte a documentação de conversão de HTML para PDF .

Conversão de URL para PDF

Este exemplo destaca como o Relatório Rápido exige o download manual de HTML, enquanto o IronPDF lida com a renderização de URLs nativamente.

Implementação do FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // Download HTML content from URL
        string htmlContent;
        using (WebClient client = new WebClient())
        {
            htmlContent = client.DownloadString("https://example.com");
        }

        using (Report report = new Report())
        {
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 800;
            htmlObject.Height = 600;
            htmlObject.Text = htmlContent;

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("webpage.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // Download HTML content from URL
        string htmlContent;
        using (WebClient client = new WebClient())
        {
            htmlContent = client.DownloadString("https://example.com");
        }

        using (Report report = new Report())
        {
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 800;
            htmlObject.Height = 600;
            htmlObject.Text = htmlContent;

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("webpage.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO
Imports System.Net

Class Program
    Shared Sub Main()
        ' Download HTML content from URL
        Dim htmlContent As String
        Using client As New WebClient()
            htmlContent = client.DownloadString("https://example.com")
        End Using

        Using report As New Report()
            Dim htmlObject As New FastReport.HTMLObject()
            htmlObject.Width = 800
            htmlObject.Height = 600
            htmlObject.Text = htmlContent

            report.Prepare()

            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("webpage.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class

Implementação do IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://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://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

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

O Relatório Rápido exige o download manual do conteúdo HTML com o WebClient e, em seguida, a incorporação desse conteúdo em um HTMLObject com dimensões fixas — uma solução alternativa que não lida corretamente com a execução de JavaScript ou URLs de recursos relativos. O recurso RenderUrlAsPdf do IronPDF renderiza diretamente a página da web em tempo real com execução completa de JavaScript usando o mecanismo Chromium. Para mais opções, consulte a documentação do URL para PDF .

Cabeçalhos e rodapés com números de página

Este exemplo demonstra a diferença de complexidade entre o sistema baseado em bandas do Relatório Rápido e a abordagem baseada em HTML do IronPDF.

Implementação do FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            report.Load("template.frx");

            // Set report page properties
            FastReport.ReportPage page = report.Pages[0] as FastReport.ReportPage;

            // Add page header
            FastReport.PageHeaderBand header = new FastReport.PageHeaderBand();
            header.Height = 50;
            FastReport.TextObject headerText = new FastReport.TextObject();
            headerText.Text = "Document Header";
            header.Objects.Add(headerText);
            page.Bands.Add(header);

            // Add page footer
            FastReport.PageFooterBand footer = new FastReport.PageFooterBand();
            footer.Height = 50;
            FastReport.TextObject footerText = new FastReport.TextObject();
            footerText.Text = "Page [Page]";
            footer.Objects.Add(footerText);
            page.Bands.Add(footer);

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("report.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            report.Load("template.frx");

            // Set report page properties
            FastReport.ReportPage page = report.Pages[0] as FastReport.ReportPage;

            // Add page header
            FastReport.PageHeaderBand header = new FastReport.PageHeaderBand();
            header.Height = 50;
            FastReport.TextObject headerText = new FastReport.TextObject();
            headerText.Text = "Document Header";
            header.Objects.Add(headerText);
            page.Bands.Add(header);

            // Add page footer
            FastReport.PageFooterBand footer = new FastReport.PageFooterBand();
            footer.Height = 50;
            FastReport.TextObject footerText = new FastReport.TextObject();
            footerText.Text = "Page [Page]";
            footer.Objects.Add(footerText);
            page.Bands.Add(footer);

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("report.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}

Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO

Class Program
    Shared Sub Main()
        Using report As New Report()
            report.Load("template.frx")

            ' Set report page properties
            Dim page As FastReport.ReportPage = TryCast(report.Pages(0), FastReport.ReportPage)

            ' Add page header
            Dim header As New FastReport.PageHeaderBand()
            header.Height = 50
            Dim headerText As New FastReport.TextObject()
            headerText.Text = "Document Header"
            header.Objects.Add(headerText)
            page.Bands.Add(header)

            ' Add page footer
            Dim footer As New FastReport.PageFooterBand()
            footer.Height = 50
            Dim footerText As New FastReport.TextObject()
            footerText.Text = "Page [Page]"
            footer.Objects.Add(footerText)
            page.Bands.Add(footer)

            report.Prepare()

            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("report.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class

Implementação do IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        };

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>");
        pdf.SaveAs("report.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        };

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>");
        pdf.SaveAs("report.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        ' Configure header and footer
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        }

        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        }

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>")
        pdf.SaveAs("report.pdf")
    End Sub
End Class

O Relatório Rápido requer o carregamento de um arquivo de modelo, a conversão de objetos de página, a criação de objetos de banda, a definição de alturas, a criação de objetos de texto, a adição a coleções de bandas e a adição de bandas às páginas. O IronPDF usa HtmlHeaderFooter com fragmentos HTML simples — você pode estilizar cabeçalhos e rodapés com CSS completo. Observe a mudança na sintaxe do número da página: [Page] torna-se {page}, e [TotalPages] torna-se {total-pages}. Para mais opções, consulte a documentação sobre cabeçalhos e rodapés .

Não há arquivos de modelo .frx

Os modelos Relatório Rápido (.frx) não funcionarão com o IronPDF. Converta seus layouts em modelos HTML/CSS:

// Relatório Rápido - loads .frx template
report.Load("report.frx");

// IronPDF - use HTML template
var html = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(html);

// Relatório Rápido - loads .frx template
report.Load("report.frx");

// IronPDF - use HTML template
var html = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(html);

' Relatório Rápido - loads .frx template
report.Load("report.frx")

' IronPDF - use HTML template
Dim html As String = File.ReadAllText("template.html")
Dim pdf = renderer.RenderHtmlAsPdf(html)

Conversão de vinculação de dados

Substitua RegisterData() pela geração direta de HTML:

// FastReport
report.RegisterData(dataSet, "Data");
report.GetDataSource("Data").Enabled = true;

// IronPDF - use string interpolation or StringBuilder
var html = new StringBuilder();
foreach (var item in data)
{
    html.Append($"<tr><td>{item.Name}</td><td>{item.Value}</td></tr>");
}
var pdf = renderer.RenderHtmlAsPdf(html.ToString());

// FastReport
report.RegisterData(dataSet, "Data");
report.GetDataSource("Data").Enabled = true;

// IronPDF - use string interpolation or StringBuilder
var html = new StringBuilder();
foreach (var item in data)
{
    html.Append($"<tr><td>{item.Name}</td><td>{item.Value}</td></tr>");
}
var pdf = renderer.RenderHtmlAsPdf(html.ToString());

Imports System.Text

' FastReport
report.RegisterData(dataSet, "Data")
report.GetDataSource("Data").Enabled = True

' IronPDF - use string interpolation or StringBuilder
Dim html As New StringBuilder()
For Each item In data
    html.Append($"<tr><td>{item.Name}</td><td>{item.Value}</td></tr>")
Next
Dim pdf = renderer.RenderHtmlAsPdf(html.ToString())

Configurações de segurança

// IronPDF security
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SecuritySettings.UserPassword = "password";
pdf.SecuritySettings.OwnerPassword = "ownerPassword";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

// IronPDF security
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SecuritySettings.UserPassword = "password";
pdf.SecuritySettings.OwnerPassword = "ownerPassword";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

' IronPDF security
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SecuritySettings.UserPassword = "password"
pdf.SecuritySettings.OwnerPassword = "ownerPassword"
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

Para obter opções de segurança abrangentes, consulte a documentação de criptografia .