Message icon
Skip to footer content
  1. IronPDF
  2. IronPDF Blog
  3. Migration Guides
  4. migration from fastreport to ironpdf
MIGRATION GUIDES

How to Migrate from FastReport to IronPDF in C#

Curtis Chau
Curtis Chau
Updated:

FastReport.NET is a powerful reporting solution built for the .NET ecosystem, featuring a visual report designer and band-based architecture for creating complex data-driven reports. However, FastReport presents significant challenges for modern PDF generation workflows: report designer dependency that limits code-first development, a steep learning curve around band-based concepts (DataBand, PageHeaderBand), limited CSS support using proprietary formatting, complex data binding with RegisterData() boilerplate, and fragmented NuGet packages requiring multiple installations. This comprehensive guide provides a step-by-step migration path from FastReport to IronPDF—a general-purpose PDF library that leverages HTML/CSS web technologies for flexible, programmatic document generation.

Why Migrate from FastReport to IronPDF?

FastReport.NET's specialization in reporting creates friction for development teams needing versatile PDF generation. Understanding these architectural differences is essential for planning your migration.

The FastReport Challenges

  1. Report Designer Dependency: Creating complex layouts requires the visual designer or deep knowledge of .frx file structure—not suitable for code-first development approaches.

  2. Steep Learning Curve: FastReport's band-based architecture (DataBand, PageHeaderBand, PageFooterBand) requires understanding report-specific concepts that don't transfer to other technologies.

  3. Limited CSS Support: Web-standard styling isn't natively supported; styling is done through FastReport's proprietary format rather than familiar CSS.

  4. Complex Data Binding: RegisterData() and DataSource connections add boilerplate for simple PDF generation scenarios.

  5. Fragmented Packages: Multiple NuGet packages needed for full functionality (FastReport.OpenSource, FastReport.OpenSource.Export.PdfSimple, etc.). PDFSimpleExport in the OpenSource edition rasterizes pages, so output PDFs contain images of text rather than selectable text.

  6. Licensing Complexity: The OpenSource edition (MIT) ships an image-based PDF fallback via PDFSimpleExport. Selectable-text PDF export, encryption, digital signing, and PDF/A require the commercial FastReport.Net package, which is published on FastReport's private NuGet feed (https://nuget.fast-report.com/api/v3/index.json), not on nuget.org. Only FastReport.Net.Demo (page-limited, watermarked) is on nuget.org.

Architecture Comparison

Aspect FastReport IronPDF
Design Approach Visual designer + .frx files HTML/CSS (web technologies)
Learning Curve Steep (band-based concepts) Gentle (HTML/CSS knowledge)
Data Binding RegisterData(), DataBand String interpolation, Razor, templating
CSS Support Limited Full CSS3 with Flexbox/Grid
Package Model Multiple packages Single package (all features)
Rendering Engine Custom report engine; OpenSource PDF export rasterizes Embedded Chromium
PDF Manipulation Export-focused Full (merge, split, security, forms)
Modern .NET .NET Framework 4.6.2+ / .NET 6+ .NET Framework 4.6.2+ / .NET 6/7/8/9+

Key Migration Benefits

  1. Web Technologies: Use familiar HTML/CSS instead of proprietary band-based layouts
  2. Code-First Development: Generate PDFs programmatically without visual designer dependency
  3. Single Package: One NuGet package includes all PDF features
  4. Modern Rendering: Latest Chromium engine for pixel-perfect CSS3 output
  5. Full PDF Manipulation: Merge, split, security, forms—not just export

Pre-Migration Preparation

Prerequisites

Ensure your environment meets these requirements:

  • .NET Framework 4.6.2+ or .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ or VS Code with C# extension
  • NuGet Package Manager access
  • IronPDF license key (free trial available at ironpdf.com)

Audit FastReport Usage

Run these commands in your solution directory to identify all FastReport references:

# Find all FastReport references
grep -r "FastReport\|\.frx\|PDFExport\|PDFSimpleExport\|DataBand\|RegisterData" --include="*.cs" --include="*.csproj" .

# Check NuGet packages
dotnet list package | grep FastReport
# Find all FastReport references
grep -r "FastReport\|\.frx\|PDFExport\|PDFSimpleExport\|DataBand\|RegisterData" --include="*.cs" --include="*.csproj" .

# Check NuGet packages
dotnet list package | grep FastReport
SHELL

Document Your Report Templates

Before migration, catalog all .frx files and their purposes:

  • Report name and purpose
  • Data sources used
  • Headers/footers configuration
  • Page numbering requirements
  • Special formatting or styling

Understanding the Paradigm Shift

The most significant change when migrating from FastReport to IronPDF is the fundamental design approach. FastReport uses band-based visual design with .frx template files and proprietary concepts like DataBand, PageHeaderBand, and RegisterData(). IronPDF uses HTML/CSS—web technologies that most developers already know.

This means converting FastReport band configurations to HTML templates, replacing RegisterData() with direct data binding via string interpolation or Razor templates, and transforming PageHeaderBand/PageFooterBand to HTML-based headers and footers.

Step-by-Step Migration Process

Step 1: Update NuGet Packages

Remove all FastReport packages and install IronPDF:

# Remove all FastReport 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 FastReport 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
SHELL

Step 2: Update Namespace References

Replace FastReport namespaces with 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
$vbLabelText   $csharpLabel

Step 3: Configure License

// 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"
$vbLabelText   $csharpLabel

Complete API Migration Reference

Core Class Mapping

FastReport Class IronPDF Equivalent
Report ChromePdfRenderer
PDFExport ChromePdfRenderer + SecuritySettings
PDFSimpleExport ChromePdfRenderer
ReportPage HTML <body> or <div>
TextObject HTML <p>, <span>, <div>
HTMLObject Direct HTML rendering
PageHeaderBand HtmlHeaderFooter
PageFooterBand HtmlHeaderFooter

Method Mapping

FastReport Method IronPDF Equivalent
report.Load("template.frx") HTML template file or string
report.RegisterData(data, "name") String interpolation or Razor
report.Prepare() N/A
report.Export(export, stream) pdf.SaveAs(path)

Page Number Placeholder Conversion

FastReport and IronPDF use different placeholder syntax for page numbers:

FastReport IronPDF
[Page] {page}
[TotalPages] {total-pages}

Code Migration Examples

HTML to PDF Conversion

This example demonstrates the fundamental difference between FastReport's HTMLObject approach and IronPDF's direct rendering.

FastReport Implementation:

// 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())
        {
            // FastReport 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);
            }
        }
    }
}
// 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())
        {
            // FastReport 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);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.Drawing
Imports System.IO

Module Program
    Sub Main()
        Using report As New Report()
            ' FastReport renders nothing unless objects live on a band that lives on a ReportPage.
            Dim page As New ReportPage()
            report.Pages.Add(page)
            page.ReportTitle = New ReportTitleBand With {.Height = Units.Millimeters * 100}

            ' Create HTML object (FastReport class is HtmlObject)
            Dim htmlObject As 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
            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 Module
$vbLabelText   $csharpLabel

IronPDF Implementation:

// 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
$vbLabelText   $csharpLabel

FastReport requires creating a Report object, attaching a ReportPage and a ReportTitleBand, placing an HtmlObject on the band with explicit bounds, preparing the report, and exporting via stream. PDFSimpleExport rasterizes the output, so the resulting PDF contains images of text rather than selectable text. IronPDF accomplishes the same result in three lines with direct HTML rendering and selectable-text output. For more options, see the HTML to PDF documentation.

URL to PDF Conversion

This example highlights how FastReport requires manual HTML download while IronPDF handles URL rendering natively.

FastReport Implementation:

// NuGet: Install-Package FastReport.OpenSource
//        Install-Package FastReport.OpenSource.Export.PdfSimple
// FastReport 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);
            }
        }
    }
}
// NuGet: Install-Package FastReport.OpenSource
//        Install-Package FastReport.OpenSource.Export.PdfSimple
// FastReport 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);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.Drawing
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        ' Download HTML content from URL
        Dim htmlContent As String
        Using client As New HttpClient()
            htmlContent = Await client.GetStringAsync("https://example.com")
        End Using

        Using report As New Report()
            Dim page As New ReportPage()
            report.Pages.Add(page)
            page.ReportTitle = New ReportTitleBand With {.Height = Units.Millimeters * 250}

            Dim htmlObject As New HtmlObject()
            htmlObject.Bounds = New RectangleF(0, 0, Units.Millimeters * 190, Units.Millimeters * 250)
            htmlObject.Text = htmlContent
            page.ReportTitle.Objects.Add(htmlObject)

            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 Function
End Module
$vbLabelText   $csharpLabel

IronPDF Implementation:

// 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
$vbLabelText   $csharpLabel

FastReport has no native URL-to-PDF — you download the HTML yourself with HttpClient, embed it in an HtmlObject on a band, and export. HtmlObject handles a limited HTML 4 subset only, with no JavaScript execution and no modern CSS, and PDFSimpleExport rasterizes the output. IronPDF's RenderUrlAsPdf directly renders the live webpage with full JavaScript execution using the embedded Chromium engine. For more options, see the URL to PDF documentation.

Headers and Footers with Page Numbers

This example demonstrates the complexity difference between FastReport's band-based system and IronPDF's HTML-based approach.

FastReport Implementation:

// 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 FastReport 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);
            }
        }
    }
}
// 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 FastReport 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);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.Drawing
Imports System.IO

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

            ' Cast to ReportPage (Report.Pages can hold dialog pages too)
            Dim page As ReportPage = TryCast(report.Pages(0), ReportPage)

            ' Page header — assigned to the band slot on the page
            page.PageHeader = New PageHeaderBand With {.Height = Units.Millimeters * 15}
            Dim headerText As New TextObject With {
                .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 FastReport page tokens [Page] and [TotalPages]
            page.PageFooter = New PageFooterBand With {.Height = Units.Millimeters * 15}
            Dim footerText As New TextObject With {
                .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()

            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
$vbLabelText   $csharpLabel

IronPDF Implementation:

// 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
$vbLabelText   $csharpLabel

FastReport requires loading a template, casting Pages[0] to ReportPage, assigning header and footer band instances to the page's PageHeader / PageFooter slots, then attaching TextObject instances with explicit Bounds to each band. IronPDF uses HtmlHeaderFooter with simple HTML fragments — you can style headers and footers with full CSS. Note the page number syntax change: [Page] becomes {page}, and [TotalPages] becomes {total-pages}. For more options, see the headers and footers documentation.

Critical Migration Notes

No .frx Template Files

FastReport templates (.frx) won't work with IronPDF. Convert your layouts to HTML/CSS templates:

// FastReport - loads .frx template
report.Load("report.frx");

// IronPDF - use HTML template
var html = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(html);
// FastReport - loads .frx template
report.Load("report.frx");

// IronPDF - use HTML template
var html = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(html);
' FastReport - loads .frx template
report.Load("report.frx")

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

Data Binding Conversion

Replace RegisterData() with direct HTML generation:

// 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())
$vbLabelText   $csharpLabel

Security Settings

// 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
$vbLabelText   $csharpLabel

For comprehensive security options, see the encryption documentation.

Post-Migration Checklist

After completing the code migration, verify the following:

  • Visual comparison of generated PDFs
  • Verify headers/footers and page numbers
  • Test with production data volumes
  • Validate security/encryption features
  • Performance benchmarking
  • Remove unused .frx template files
  • Delete FastReport-related code
  • Update documentation

Additional Resources

Migrating from FastReport to IronPDF eliminates the visual designer dependency, band-based learning curve, and fragmented package model. The transition to HTML/CSS-based PDF generation leverages familiar web technologies while providing full PDF manipulation capabilities—merge, split, security, and forms—in a single package.

Please noteFastReport is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by Fast Reports. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.

Curtis Chau
Curtis Chau
  Chat with engineering team now
Technical Writer

Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.

...

Read More

Related Articles

30-day trial → Full product. No limits. No card. Start Free Trial

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me