O Relatório Rápido .NET é uma poderosa solução de geração de relatórios criada para o ecossistema .NET , apresentando um designer visual de relatórios e uma arquitetura baseada em bandas para a criação de relatórios complexos orientados a dados. No entanto, o Relatório Rápido apresenta desafios significativos para os fluxos de trabalho modernos de geração de PDFs: dependência do designer de relatórios que limita o desenvolvimento "code-first", uma curva de aprendizado acentuada em torno de conceitos baseados em bandas (DataBand, PageHeaderBand), suporte limitado a CSS usando formatação proprietária, vinculação de dados complexa com o código boilerplate RegisterData() e pacotes NuGet fragmentados que exigem múltiplas instalações. Este guia completo fornece um caminho de migração passo a passo do Relatório Rápido para o IronPDF— uma biblioteca PDF de uso geral que aproveita as tecnologias web HTML/CSS para geração flexível e programática de documentos.
A especialização do FastReport.NET em geração de relatórios cria atritos para equipes de desenvolvimento que precisam de geração versátil de PDFs. Compreender essas diferenças arquitetônicas é essencial para o planejamento da sua migração.
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".
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.
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.
Vinculação de dados complexa: as conexões RegisterData() e DataSource adicionam código repetitivo para cenários simples de geração de PDF.
Pacotes fragmentados: Vários pacotes NuGet são necessários para a funcionalidade completa (FastReport.OpenSource, FastReport.OpenSource.Export.PdfSimple, etc.). PDFSimpleExport na edição OpenSource rasteriza páginas, então os PDFs gerados contêm imagens de texto ao invés de texto selecionável.
Complexidade de Licenciamento: A edição OpenSource (MIT) envia uma alternativa de PDF baseada em imagem via PDFSimpleExport. A exportação de PDF com texto selecionável, criptografia, assinatura digital e PDF/A requer o pacote comercial FastReport.Net, que é publicado no feed privado do NuGet da Relatório Rápido (https://nuget.fast-report.com/api/v3/index.json), não no nuget.org. Apenas FastReport.Net.Demo (com limite de páginas, marca d'água) está no nuget.org.
| Aspecto | Relatório Rápido | IronPDF |
|---|---|---|
| Abordagem de projeto | Designer visual + arquivos .frx | HTML/CSS (tecnologias web) |
| Curva de Aprendizagem | Íngreme (conceitos baseados em bandas) | Gentil (conhecimento de HTML/CSS) |
| Vinculação de dados | RegistrarDados(), BandaDeDados | Interpolação de strings, Razor, criação de modelos |
| Suporte a CSS | Limitado | CSS3 completo com Flexbox/Grid |
| Modelo de pacote | Vários pacotes | Pacote único (todos os recursos) |
| Motor de renderização | Motor de relatório personalizado; exportação PDF OpenSource rasteriza | Chromium incorporado |
| Manipulação de PDF | Focado na exportação | Completo (fusão, divisão, segurança, formulários) |
| .NET moderno | .NET Framework 4.6.2+ / .NET 6+ | .NET Framework 4.6.2+ / .NET 6/7/8/9+ |
Certifique-se de que seu ambiente atenda a estes requisitos:
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 FastReportAntes da migração, catalogue todos os arquivos .frx e seus propósitos:
A mudança mais significativa ao migrar do Relatório Rápido para o IronPDF é a abordagem de design fundamental. Relatório Rápido usa 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.
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 IronPdfSubstitua os namespaces do Relatório Rápido pelo IronPDF:
// Remove these
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;
// Add this
using IronPdf;Imports IronPdf// 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"| Classe Relatório Rápido | Equivalente ao IronPDF |
|---|---|
Report | ChromePdfRenderer |
PDFExport | ChromePdfRenderer + SecuritySettings |
PDFSimpleExport | ChromePdfRenderer |
ReportPage | HTML <body> ou <div> |
TextObject | HTML <p>, <span>, <div> |
HTMLObject | Renderização direta de HTML |
PageHeaderBand | HtmlHeaderFooter |
PageFooterBand | HtmlHeaderFooter |
| Método Relatório Rápido | Equivalente ao IronPDF |
|---|---|
report.Load("template.frx") | Arquivo de modelo HTML ou string |
report.RegisterData(data, "name") | Interpolação de strings ou Razor |
report.Prepare() | N / D |
report.Export(export, stream) | pdf.SaveAs(path) |
O Relatório Rápido e o IronPDF usam sintaxes diferentes para marcadores de posição de números de página:
| Relatório Rápido | IronPDF |
|---|---|
[Page] | {page} |
[TotalPages] | {total-pages} |
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
// Install-Package FastReport.OpenSource.Export.PdfSimple
using FastReport;
using FastReport.Export.PdfSimple;
using System.Drawing;
using System.IO;
class Program
{
static void Main()
{
using (Report report = new Report())
{
// Relatório Rápido renders nothing unless objects live on a band that lives on a ReportPage.
ReportPage page = new ReportPage();
report.Pages.Add(page);
page.ReportTitle = new ReportTitleBand { Height = Units.Millimeters * 100 };
// Create HTML object (FastReport class is HtmlObject)
HtmlObject htmlObject = new HtmlObject();
htmlObject.Bounds = new RectangleF(0, 0, Units.Millimeters * 190, Units.Millimeters * 100);
htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>";
page.ReportTitle.Objects.Add(htmlObject);
report.Prepare();
// PDFSimpleExport rasterizes each page — text is not selectable
PDFSimpleExport pdfExport = new PDFSimpleExport();
using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
{
report.Export(pdfExport, fs);
}
}
}
}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");
}
}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 ClassFastReport requer criar um objeto Report, anexar um ReportPage e um ReportTitleBand, posicionar um HtmlObject na banda com limites explícitos, preparar o relatório e exportar via stream. PDFSimpleExport rasteriza o resultado, então o PDF gerado contém imagens de texto ao invés de texto selecionável. O IronPDF alcança o mesmo resultado em três linhas com rendering HTML direto e saída de texto selecionável. Para mais opções, consulte a documentação de conversão de HTML 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
// Install-Package FastReport.OpenSource.Export.PdfSimple
// Relatório Rápido has no native URL-to-PDF. You must download the HTML yourself
// and feed it into HtmlObject — which handles only a limited HTML 4 subset,
// no JavaScript and no modern CSS.
using FastReport;
using FastReport.Export.PdfSimple;
using System.Drawing;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
// Download HTML content from URL
string htmlContent;
using (var client = new HttpClient())
{
htmlContent = await client.GetStringAsync("https://example.com");
}
using (Report report = new Report())
{
ReportPage page = new ReportPage();
report.Pages.Add(page);
page.ReportTitle = new ReportTitleBand { Height = Units.Millimeters * 250 };
HtmlObject htmlObject = new HtmlObject();
htmlObject.Bounds = new RectangleF(0, 0, Units.Millimeters * 190, Units.Millimeters * 250);
htmlObject.Text = htmlContent;
page.ReportTitle.Objects.Add(htmlObject);
report.Prepare();
PDFSimpleExport pdfExport = new PDFSimpleExport();
using (FileStream fs = new FileStream("webpage.pdf", FileMode.Create))
{
report.Export(pdfExport, fs);
}
}
}
}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");
}
}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 ClassFastReport não tem conversão nativa de URL-para-PDF — você baixa o HTML manualmente com HttpClient, o incorpora em um HtmlObject em uma banda, e exporta. HtmlObject lida apenas com um subconjunto limitado de HTML 4, sem execução de JavaScript e sem CSS moderno, e PDFSimpleExport rasteriza o resultado. O RenderUrlAsPdf do IronPDF renderiza diretamente a página da web ao vivo com execução completa de JavaScript usando o mecanismo Chromium embutido. Para mais opções, veja a documentação de URL para PDF.
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
// Install-Package FastReport.OpenSource.Export.PdfSimple
using FastReport;
using FastReport.Export.PdfSimple;
using System.Drawing;
using System.IO;
class Program
{
static void Main()
{
using (Report report = new Report())
{
report.Load("template.frx");
// Cast to ReportPage (Report.Pages can hold dialog pages too)
ReportPage page = report.Pages[0] as ReportPage;
// Page header — assigned to the band slot on the page
page.PageHeader = new PageHeaderBand { Height = Units.Millimeters * 15 };
TextObject headerText = new TextObject
{
Bounds = new RectangleF(0, 0, Units.Millimeters * 190, Units.Millimeters * 10),
Text = "Document Header",
HorzAlign = HorzAlign.Center
};
page.PageHeader.Objects.Add(headerText);
// Page footer with Relatório Rápido page tokens [Page] and [TotalPages]
page.PageFooter = new PageFooterBand { Height = Units.Millimeters * 15 };
TextObject footerText = new TextObject
{
Bounds = new RectangleF(0, 0, Units.Millimeters * 190, Units.Millimeters * 10),
Text = "Page [Page] of [TotalPages]",
HorzAlign = HorzAlign.Right
};
page.PageFooter.Objects.Add(footerText);
report.Prepare();
PDFSimpleExport pdfExport = new PDFSimpleExport();
using (FileStream fs = new FileStream("report.pdf", FileMode.Create))
{
report.Export(pdfExport, fs);
}
}
}
}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
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 ClassFastReport requer carregar um modelo, converter Pages[0] para ReportPage, atribuir instâncias de banda de cabeçalho e rodapé aos slots PageHeader / PageFooter da página, em seguida anexar instâncias TextObject com Bounds explícitos para cada banda.IronPDF usa HtmlHeaderFooter com fragmentos simples de HTML — você pode estilizar cabeçalhos e rodapés com CSS completo. Observe a mudança de sintaxe do número de 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 .
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);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());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())//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.FullPrintRightsPara obter opções de segurança abrangentes, consulte a documentação de criptografia .
Após concluir a migração do código, verifique o seguinte:
A migração do Relatório Rápido para o IronPDF elimina a dependência do designer visual, a curva de aprendizado baseada em bandas e o modelo de pacotes fragmentado. A transição para a geração de PDFs baseada em HTML/CSS aproveita tecnologias web já conhecidas, ao mesmo tempo que oferece recursos completos de manipulação de PDFs — mesclagem, divisão, segurança e formulários — em um único pacote.
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 bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
