FastReport.NET ist eine leistungsstarke Berichtslösung, die für das .NET-Ökosystem entwickelt wurde und einen visuellen Berichtsdesigner sowie eine bandbasierte Architektur zur Erstellung komplexer datengesteuerter Berichte bietet. FastReportstellt jedoch erhebliche Herausforderungen für moderne PDF-Generierungs-Workflows dar: die Abhängigkeit vom Berichtsdesigner, die die Code-First-Entwicklung einschränkt, eine steile Lernkurve für bandbasierte Konzepte (DataBand, PageHeaderBand), begrenzte CSS-Unterstützung mit proprietärer Formatierung, komplexe Datenbindung mit RegisterData()-Boilerplate und fragmentierte NuGet-Pakete, die mehrere Installationen erfordern. Dieser umfassende Leitfaden bietet einen schrittweisen Migrationspfad von FastReportzu IronPDF- einer Allzweck-PDF-Bibliothek, die HTML/CSS-Webtechnologien für eine flexible, programmatische Dokumentenerstellung nutzt.
Die Spezialisierung von FastReport.NET auf das Berichtswesen schafft Reibungsverluste für Entwicklungsteams, die eine vielseitige PDF-Erstellung benötigen. Das Verständnis dieser architektonischen Unterschiede ist für die Planung Ihrer Migration unerlässlich.
Abhängigkeit vom Report Designer: Die Erstellung komplexer Layouts erfordert den visuellen Designer oder tiefgreifende Kenntnisse der .frx-Dateistruktur – nicht geeignet für Code-First-Entwicklungsansätze.
Steile Lernkurve: Die bandbasierte Architektur von FastReport(DataBand, PageHeaderBand, PageFooterBand) erfordert das Verständnis berichtspezifischer Konzepte, die sich nicht auf andere Technologien übertragen lassen.
Eingeschränkte CSS-Unterstützung: Webstandard-Styling wird nicht nativ unterstützt; die Gestaltung erfolgt durch das proprietäre Format von FastReportund nicht durch das bekannte CSS.
Komplexe Datenbindung: RegisterData() und DataSource-Verbindungen erfordern zusätzlichen Code für einfache PDF-Generierungsszenarien.
Fragmentierte Pakete: Mehrere NuGet Pakete werden für die volle Funktionalität benötigt (FastReport.OpenSource, FastReport.OpenSource.Export.PdfSimple usw.). PDFSimpleExport in der OpenSource-Edition rasterisiert Seiten, sodass die ausgegebenen PDFs Bilder von Text enthalten, anstatt auswählbaren Text.
Lizenzkomplexität: Die OpenSource-Edition (MIT) liefert ein bildbasiertes PDF-Fallback über PDFSimpleExport. PDF-Export mit auswählbarem Text, Verschlüsselung, digitale Signierung und PDF/A erfordern das kommerzielle FastReport.Net-Paket, das auf FastReports privatem NuGet-Feed (https://nuget.fast-report.com/api/v3/index.json) veröffentlicht wird, nicht auf nuget.org. Nur FastReport.Net.Demo (seitenbegrenzt, mit Wasserzeichen) ist auf nuget.org.
| Aspekt | FastReport | IronPDF |
|---|---|---|
| Gestaltungsansatz | Visueller Designer + .frx-Dateien | HTML/CSS (Webtechnologien) |
| Lernkurve | Steep (bandbasierte Konzepte) | Sanft (HTML/CSS-Kenntnisse) |
| Datenbindung | RegisterData(), DataBand | String-Interpolation, Razor, Templating |
| CSS-Unterstützung | Beschränkt | Vollständiges CSS3 mit Flexbox/Grid |
| Package Model | Mehrere Pakete | Einzelnes Paket (alle Funktionen) |
| Rendering Engine | Benutzerdefinierte Bericht-Engine; OpenSource PDF-Export rasterisiert | Eingebettetes Chromium |
| PDF-Bearbeitung | Exportorientiert | Vollständig (Zusammenführen, Teilen, Sicherheit, Formulare) |
| Modernes .NET | .NET Framework 4.6.2+ / .NET 6+ | .NET Framework 4.6.2+ / .NET 6/7/8/9+ |
Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:
Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus, um alle FastReport-Referenzen zu identifizieren:
# Find all FastReportreferences
grep -r "FastReport\|\.frx\|PDFExport\|PDFSimpleExport\|DataBand\|RegisterData" --include="*.cs" --include="*.csproj" .
# Check NuGet packages
dotnet list package | grep FastReportVor der Migration alle .frx-Dateien und deren Zwecke katalogisieren:
Die wichtigste Änderung bei der Migration von FastReportzu IronPDF ist der grundlegende Designansatz. FastReportverwendet ein bandbasiertes visuellen Design mit .frx-Vorlagendateien und proprietären Konzepten wie DataBand, PageHeaderBand und RegisterData().IronPDF verwendet HTML/CSS-Webtechnologien, die den meisten Entwicklern bereits bekannt sind.
Das bedeutet, dass FastReport-Bandkonfigurationen in HTML-Vorlagen umgewandelt werden, RegisterData() durch direkte Datenbindung über String-Interpolation oder Razor-Vorlagen ersetzt wird und PageHeaderBand/PageFooterBand in HTML-basierte Kopf- und Fußzeilen umgewandelt werden.
Entfernen Sie alle FastReport-Pakete und installieren Sie IronPDF:
# Remove all FastReportpackages
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 IronPdfErsetzen Sie FastReport-Namensräume durch 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"| FastReport-Klasse | IronPDF-Äquivalent |
|---|---|
Report | ChromePdfRenderer |
PDFExport | ChromePdfRenderer + SecuritySettings |
PDFSimpleExport | ChromePdfRenderer |
ReportPage | HTML <body> oder <div> |
TextObject | HTML <p>, <span>, <div> |
HTMLObject | Direkte HTML-Wiedergabe |
PageHeaderBand | HtmlHeaderFooter |
PageFooterBand | HtmlHeaderFooter |
| FastReport-Methode | IronPDF-Äquivalent |
|---|---|
report.Load("template.frx") | HTML-Vorlagendatei oder String |
report.RegisterData(data, "name") | String-Interpolation oder Razor |
report.Prepare() | Nicht anwendbar |
report.Export(export, stream) | pdf.SaveAs(path) |
FastReport und IronPDF verwenden unterschiedliche Platzhalter-Syntaxen für Seitenzahlen:
| FastReport | IronPDF |
|---|---|
[Page] | {page} |
[TotalPages] | {total-pages} |
Dieses Beispiel verdeutlicht den grundlegenden Unterschied zwischen dem HTMLObject-Ansatz von FastReportund dem direkten Rendering von IronPDF.
FastReport-Einführung:
// 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())
{
// FastReportrenders 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);
}
}
}
}IronPDF-Implementierung:
// 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 erfordert das Erstellen eines Report-Objekts, das Anfügen eines ReportPage und eines ReportTitleBand, das Platzieren eines HtmlObject auf dem Band mit expliziten Grenzen, die Vorbereitung des Berichts und den Export über den Stream. PDFSimpleExport rasterisiert die Ausgabe, sodass das resultierende PDF Bilder von Text enthält, anstatt auswählbaren Text.IronPDF erreicht das gleiche Ergebnis in drei Zeilen mit direktem HTML-Rendering und wählbarem Textausgang. Weitere Optionen finden Sie in der HTML zu PDF Dokumentation.
In diesem Beispiel wird deutlich, dass FastReporteinen manuellen HTML-Download erfordert, während IronPDF das URL-Rendering nativ handhabt.
FastReport-Einführung:
// NuGet: Install-Package FastReport.OpenSource
// Install-Package FastReport.OpenSource.Export.PdfSimple
// FastReporthas 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);
}
}
}
}IronPDF-Implementierung:
// 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 hat keine native URL-zu-PDF-Funktion — Sie laden das HTML selbst mit HttpClient herunter, betten es in ein HtmlObject auf einem Band ein und exportieren. HtmlObject verarbeitet nur einen begrenzten HTML 4-Subset, ohne JavaScript-Ausführung und ohne modernes CSS, und PDFSimpleExport rasterisiert die Ausgabe. IronPDFs RenderUrlAsPdf rendert direkt die Live-Webseite mit vollständiger JavaScript-Ausführung unter Verwendung der eingebetteten Chromium-Engine. Für weitere Optionen siehe die URL-zu-PDF-Dokumentation.
Dieses Beispiel verdeutlicht den Komplexitätsunterschied zwischen dem bandbasierten System von FastReportund dem HTML-basierten Ansatz von IronPDF.
FastReport-Einführung:
// 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 FastReportpage 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);
}
}
}
}IronPDF-Implementierung:
// 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 erfordert das Laden einer Vorlage, das Casting von Pages[0] zu ReportPage, das Zuweisen von Header- und Footer-Band-Instanzen zu den PageHeader / PageFooter-Slots der Seite, dann das Anfügen von TextObject-Instanzen mit explizitem Bounds an jedes Band.IronPDF verwendet HtmlHeaderFooter mit einfachen HTML-Fragmenten — Sie können Header und Footer mit vollem CSS stylen. Beachten Sie die Syntaxänderung für Seitenzahlen: [Page] wird zu {page}, und [TotalPages] wird zu {total-pages}. Weitere Optionen finden Sie in der Kopf- und Fußzeilen-Dokumentation.
FastReport-Vorlagen (.frx) können nicht mit IronPDF verwendet werden. Konvertieren Sie Ihre Layouts in HTML/CSS-Vorlagen:
// 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)Ersetzen Sie RegisterData() durch direkte HTML-Generierung:
// 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.FullPrintRightsAusführliche Informationen zu den Sicherheitsoptionen finden Sie in der Dokumentation zur Verschlüsselung .
Überprüfen Sie nach Abschluss der Codemigration Folgendes:
Die Migration von FastReportzu IronPDF beseitigt die Abhängigkeit vom visuellen Designer, die bandbasierte Lernkurve und das fragmentierte Paketmodell. Der Übergang zur HTML/CSS-basierten PDF-Generierung nutzt vertraute Webtechnologien und bietet gleichzeitig alle Funktionen zur PDF-Bearbeitung - Zusammenführen, Teilen, Sicherheit und Formulare - in einem einzigen Paket.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
