Die Migration von SQL Server Reporting Services (SSRS) zu IronPDF verwandelt Ihren PDF-Generierungs-Workflow von einer schwergewichtigen serverbasierten Infrastruktur in eine leichtgewichtige, prozessinterne Bibliothek, die direkt in jede .NET-Anwendung eingebettet werden kann. Dieser Leitfaden bietet einen vollständigen, schrittweisen Migrationspfad, der SQL Server-Abhängigkeiten, den Overhead des Berichtsservers und die Bindung an das Microsoft-Ökosystem eliminiert.
SQL Server Reporting Services (SSRS) ist Microsofts Unternehmensberichtsplattform — eine komplette Suite zur Erstellung, Bereitstellung und Verwaltung von Berichten, eng integriert mit dem SQL Server-Ökosystem. Microsoft hat bestätigt, dass SSRS 2022 die letzte eigenständige Version ist: ab SQL Server 2025 konsolidieren sich On-Premises-Berichte in den Power BI Report Server (PBIRS), und keine neuen SSRS-Versionen werden ausgeliefert. SSRS2022 erhält Sicherheitsupdates bis 11. Januar 2033 in Übereinstimmung mit dem SQL Server 2022-Lebenszyklus (siehe die Reporting Services Consolidation FAQ).
Für viele PDF-Erstellungsszenarien ist die SSRS-Infrastruktur übermäßig. Wichtige Gründe für eine Migration sind:
Microsoft.ReportingServices.ReportViewerControl.WebForms / .Winforms-Pakete sind nur auf das .NET Framework 4.0–4.8.1 ausgelegt. .NET Core / .NET 5+-Benutzer verlassen sich auf den Community-Port ReportViewerCore.NETCore.| Ihr Bedarf | SSRS-Gemeinkosten |
|---|---|
| Rechnungen generieren | Vollständiger Berichtsserver |
| Datentabellen exportieren | SQL Server-Lizenz |
| PDFs aus Daten erstellen | Windows-Server |
| Einfache Dokumentenerstellung | Berichtsabonnements |
IronPDF bietet prozessbegleitende PDF-Erzeugung ohne Server-Infrastruktur.
| Feature | SSRS | IronPDF |
|---|---|---|
| Abhängigkeit | Benötigt SQL Server | Keine spezifische Datenbank-Abhängigkeit |
| Einsatz | Serverbasiert | Bibliothek (eingebettet in Anwendungen) |
| Integration | Enge Integration mit Microsoft | Funktioniert mit jeder Datenquelle |
| Datenvisualisierung | Umfangreiche native Optionen | PDF-orientierte Visualisierungen |
| Komplexität | Hoch (Servereinrichtung erforderlich) | Mäßig bis gering (Einrichtung der Bibliothek) |
| Kosten | SQL Server-Lizenzierungskosten | Kosten für die Lizenzierung pro Entwickler |
| HTML zu PDF | Nein | Vollständiges Chromium |
| URL zu PDF | Nein | Ja |
| CSS-Unterstützung | Beschränkt | Vollständig CSS3 |
| JavaScript | Nein | Vollständiger ES2024 |
IronPDF ist im Gegensatz zu SSRS nicht an eine bestimmte Datenbank oder ein Server-Ökosystem gebunden. Es bietet Entwicklern eine flexible Bibliothek zur dynamischen Erstellung, Bearbeitung und Manipulation von PDF-Dokumenten direkt in C#. Diese Entkopplung von einer serverbasierten Infrastruktur bietet einen spürbaren Vorteil: Sie ist einfach und anpassungsfähig und eignet sich für eine Vielzahl von Anwendungen, die über das Berichtswesen hinausgehen.
Für Teams, die modernes .NET annehmen, bietet IronPDF eine Chromium-Rendering-Engine, die die Infrastrukturkomplexität von SSRS eliminiert.
# SSRS itself is server-based, but the in-process LocalReport API
# ships via Microsoft's ReportViewerControl packages (latest 150.1652.0,
# June 2024 — .NET Framework 4.0–4.8.1 only).
dotnet remove package Microsoft.ReportingServices.ReportViewerControl.WebForms
dotnet remove package Microsoft.ReportingServices.ReportViewerControl.Winforms
# If your project used the community .NET Core port, remove it too:
# dotnet remove package ReportViewerCore.NETCore
# Install IronPDF
dotnet add package IronPdf// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// Before: SSRS
using Microsoft.Reporting.WebForms;
using Microsoft.Reporting.WinForms;
// After: IronPDF
using IronPdf;
using IronPdf.Rendering;Imports Microsoft.Reporting.WebForms
Imports Microsoft.Reporting.WinForms
' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering| SSRS-Konzept | IronPDF-Äquivalent | Notizen |
|---|---|---|
LocalReport | ChromePdfRenderer | Kern-Rendering |
ServerReport | RenderUrlAsPdf() | URL-basiertes Rendering |
.rdlc-Dateien | HTML/CSS-Vorlagen | Format der Vorlage |
ReportParameter | String-Interpolation | Parameter |
ReportDataSource | C#-Daten + HTML | Datenbindung |
LocalReport.Render("PDF") | RenderHtmlAsPdf() | PDF-Ausgabe |
SubReport | Zusammengeführte PDFs | Verschachtelte Berichte |
Report Server URL | Nicht erforderlich | Kein Server erforderlich |
ReportViewer Steuerung | Nicht erforderlich | Direkte PDF-Erzeugung |
| Formate exportieren | PDF ist nativ | Gezielte Ausgabe |
Vor (SSRS):
// SSRS - SQL Server Reporting Services
using System;
using System.Data;
using System.Data.SqlClient;
using Microsoft.Reporting.WebForms;
using System.IO;
class SSRSHtmlToPdf
{
static void Main()
{
// Create a ReportViewer instance
var reportViewer = new ReportViewer();
reportViewer.ProcessingMode = ProcessingMode.Local;
// Load RDLC report definition
reportViewer.LocalReport.ReportPath = "Report.rdlc";
// Add HTML content as a parameter or dataset
var htmlContent = "<h1>Hello World</h1><p>This is HTML content.</p>";
var param = new ReportParameter("HtmlContent", htmlContent);
reportViewer.LocalReport.SetParameters(param);
// Render the report to PDF
string mimeType, encoding, fileNameExtension;
string[] streams;
Warning[] warnings;
byte[] bytes = reportViewer.LocalReport.Render(
"PDF",
null,
out mimeType,
out encoding,
out fileNameExtension,
out streams,
out warnings);
File.WriteAllBytes("output.pdf", bytes);
}
}' SSRS - SQL Server Reporting Services
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.Reporting.WebForms
Imports System.IO
Class SSRSHtmlToPdf
Shared Sub Main()
' Create a ReportViewer instance
Dim reportViewer As New ReportViewer()
reportViewer.ProcessingMode = ProcessingMode.Local
' Load RDLC report definition
reportViewer.LocalReport.ReportPath = "Report.rdlc"
' Add HTML content as a parameter or dataset
Dim htmlContent As String = "<h1>Hello World</h1><p>This is HTML content.</p>"
Dim param As New ReportParameter("HtmlContent", htmlContent)
reportViewer.LocalReport.SetParameters(param)
' Render the report to PDF
Dim mimeType As String
Dim encoding As String
Dim fileNameExtension As String
Dim streams As String()
Dim warnings As Warning()
Dim bytes As Byte() = reportViewer.LocalReport.Render( _
"PDF", _
Nothing, _
mimeType, _
encoding, _
fileNameExtension, _
streams, _
warnings)
File.WriteAllBytes("output.pdf", bytes)
End Sub
End ClassNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfHtmlToPdf
{
static void Main()
{
// Create a ChromePdfRenderer instance
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF
var htmlContent = "<h1>Hello World</h1><p>This is HTML content.</p>";
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF file
pdf.SaveAs("output.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System
Module IronPdfHtmlToPdf
Sub Main()
' Create a ChromePdfRenderer instance
Dim renderer = New ChromePdfRenderer()
' Convert HTML string to PDF
Dim htmlContent = "<h1>Hello World</h1><p>This is HTML content.</p>"
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Save the PDF file
pdf.SaveAs("output.pdf")
End Sub
End ModuleDieses Beispiel verdeutlicht den grundlegenden architektonischen Unterschied. SSRS erfordert die Erstellung einer ReportViewer-Instanz, das Laden einer .rdlc-Berichtdefinitionsdatei, das Festlegen von Parametern und dann den Aufruf von LocalReport.Render("PDF") mit mehreren out-Parametern für Metadaten.
IronPDF verwendet einen ChromePdfRenderer mit RenderHtmlAsPdf() in nur drei Codezeilen. Es sind keine Berichtsdefinitionsdateien, keine Parameterobjekte und keine Metadaten erforderlich. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.
Vor (SSRS):
// SSRS - SQL Server Reporting Services
using System;
using System.IO;
using System.Net;
using Microsoft.Reporting.WebForms;
class SSRSUrlToPdf
{
static void Main()
{
// Download HTML content from URL
string url = "https://example.com";
string htmlContent;
using (var client = new WebClient())
{
htmlContent = client.DownloadString(url);
}
// Create RDLC report with header/footer configuration
var reportViewer = new ReportViewer();
reportViewer.ProcessingMode = ProcessingMode.Local;
reportViewer.LocalReport.ReportPath = "WebReport.rdlc";
// Set parameters for header and footer
var parameters = new ReportParameter[]
{
new ReportParameter("HeaderText", "Company Report"),
new ReportParameter("FooterText", "Page " + DateTime.Now.ToString()),
new ReportParameter("HtmlContent", htmlContent)
};
reportViewer.LocalReport.SetParameters(parameters);
// Render to PDF
string mimeType, encoding, fileNameExtension;
string[] streams;
Warning[] warnings;
byte[] bytes = reportViewer.LocalReport.Render(
"PDF", null, out mimeType, out encoding,
out fileNameExtension, out streams, out warnings);
File.WriteAllBytes("webpage.pdf", bytes);
}
}' SSRS - SQL Server Reporting Services
Imports System
Imports System.IO
Imports System.Net
Imports Microsoft.Reporting.WebForms
Class SSRSUrlToPdf
Shared Sub Main()
' Download HTML content from URL
Dim url As String = "https://example.com"
Dim htmlContent As String
Using client As New WebClient()
htmlContent = client.DownloadString(url)
End Using
' Create RDLC report with header/footer configuration
Dim reportViewer As New ReportViewer()
reportViewer.ProcessingMode = ProcessingMode.Local
reportViewer.LocalReport.ReportPath = "WebReport.rdlc"
' Set parameters for header and footer
Dim parameters As ReportParameter() = {
New ReportParameter("HeaderText", "Company Report"),
New ReportParameter("FooterText", "Page " & DateTime.Now.ToString()),
New ReportParameter("HtmlContent", htmlContent)
}
reportViewer.LocalReport.SetParameters(parameters)
' Render to PDF
Dim mimeType As String, encoding As String, fileNameExtension As String
Dim streams As String()
Dim warnings As Warning()
Dim bytes As Byte() = reportViewer.LocalReport.Render(
"PDF", Nothing, mimeType, encoding,
fileNameExtension, streams, warnings)
File.WriteAllBytes("webpage.pdf", bytes)
End Sub
End ClassNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class IronPdfUrlToPdf
{
static void Main()
{
// Create a ChromePdfRenderer instance
var renderer = new ChromePdfRenderer();
// Configure rendering options with header and footer
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center'>Company Report</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages} - " + DateTime.Now.ToString("MM/dd/yyyy") + "</div>"
};
// Convert URL to PDF
string url = "https://example.com";
var pdf = renderer.RenderUrlAsPdf(url);
// Save the PDF file
pdf.SaveAs("webpage.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering
Imports System
Class IronPdfUrlToPdf
Shared Sub Main()
' Create a ChromePdfRenderer instance
Dim renderer As New ChromePdfRenderer()
' Configure rendering options with header and footer
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center'>Company Report</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages} - " & DateTime.Now.ToString("MM/dd/yyyy") & "</div>"
}
' Convert URL to PDF
Dim url As String = "https://example.com"
Dim pdf = renderer.RenderUrlAsPdf(url)
' Save the PDF file
pdf.SaveAs("webpage.pdf")
End Sub
End ClassSSRS kann URLs nicht direkt in PDF konvertieren. Sie müssen HTML-Inhalt manuell mit WebClient.DownloadString() herunterladen, eine separate .rdlc-Berichtdatei erstellen, das HTML und den Kopf-/Fußzeilentext als ReportParameter-Arrays übermitteln und dann mit der komplexen Render()-Methodensignatur rendern.
IronPDF's RenderUrlAsPdf() erledigt den gesamten Prozess in einem einzigen Aufruf. Kopf- und Fußzeilen werden mit HtmlHeaderFooter-Objekten konfiguriert, die vollständiges HTML/CSS und Platzhalter wie {page} und {total-pages} unterstützen. Erfahren Sie mehr in unseren Tutorials.
Vor (SSRS):
// SSRS - SQL Server Reporting Services
using System;
using System.Data;
using System.Data.SqlClient;
using Microsoft.Reporting.WebForms;
using System.IO;
class SSRSDatabaseReport
{
static void Main()
{
// Create a ReportViewer instance
var reportViewer = new ReportViewer();
reportViewer.ProcessingMode = ProcessingMode.Local;
reportViewer.LocalReport.ReportPath = "SalesReport.rdlc";
// Create database connection and fetch data
string connString = "Server=localhost;Database=SalesDB;Integrated Security=true;";
using (var connection = new SqlConnection(connString))
{
var adapter = new SqlDataAdapter("SELECT * FROM Sales", connection);
var dataSet = new DataSet();
adapter.Fill(dataSet, "Sales");
// Bind data to report
var dataSource = new ReportDataSource("SalesDataSet", dataSet.Tables[0]);
reportViewer.LocalReport.DataSources.Clear();
reportViewer.LocalReport.DataSources.Add(dataSource);
}
// Render to PDF
string mimeType, encoding, fileNameExtension;
string[] streams;
Warning[] warnings;
byte[] bytes = reportViewer.LocalReport.Render(
"PDF", null, out mimeType, out encoding,
out fileNameExtension, out streams, out warnings);
File.WriteAllBytes("sales-report.pdf", bytes);
}
}' SSRS - SQL Server Reporting Services
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.Reporting.WebForms
Imports System.IO
Class SSRSDatabaseReport
Shared Sub Main()
' Create a ReportViewer instance
Dim reportViewer = New ReportViewer()
reportViewer.ProcessingMode = ProcessingMode.Local
reportViewer.LocalReport.ReportPath = "SalesReport.rdlc"
' Create database connection and fetch data
Dim connString As String = "Server=localhost;Database=SalesDB;Integrated Security=true;"
Using connection = New SqlConnection(connString)
Dim adapter = New SqlDataAdapter("SELECT * FROM Sales", connection)
Dim dataSet = New DataSet()
adapter.Fill(dataSet, "Sales")
' Bind data to report
Dim dataSource = New ReportDataSource("SalesDataSet", dataSet.Tables(0))
reportViewer.LocalReport.DataSources.Clear()
reportViewer.LocalReport.DataSources.Add(dataSource)
End Using
' Render to PDF
Dim mimeType As String, encoding As String, fileNameExtension As String
Dim streams As String()
Dim warnings As Warning()
Dim bytes As Byte() = reportViewer.LocalReport.Render(
"PDF", Nothing, mimeType, encoding,
fileNameExtension, streams, warnings)
File.WriteAllBytes("sales-report.pdf", bytes)
End Sub
End ClassNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Data;
using System.Data.SqlClient;
using System.Text;
class IronPdfDatabaseReport
{
static void Main()
{
// Create database connection and fetch data
string connString = "Server=localhost;Database=SalesDB;Integrated Security=true;";
var dataTable = new DataTable();
using (var connection = new SqlConnection(connString))
{
var adapter = new SqlDataAdapter("SELECT * FROM Sales", connection);
adapter.Fill(dataTable);
}
// Build HTML table from data
var htmlBuilder = new StringBuilder();
htmlBuilder.Append("<h1>Sales Report</h1><table border='1'><tr>");
foreach (DataColumn column in dataTable.Columns)
htmlBuilder.Append($"<th>{column.ColumnName}</th>");
htmlBuilder.Append("</tr>");
foreach (DataRow row in dataTable.Rows)
{
htmlBuilder.Append("<tr>");
foreach (var item in row.ItemArray)
htmlBuilder.Append($"<td>{item}</td>");
htmlBuilder.Append("</tr>");
}
htmlBuilder.Append("</table>");
// Convert to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString());
pdf.SaveAs("sales-report.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports System.Text
Class IronPdfDatabaseReport
Shared Sub Main()
' Create database connection and fetch data
Dim connString As String = "Server=localhost;Database=SalesDB;Integrated Security=true;"
Dim dataTable As New DataTable()
Using connection As New SqlConnection(connString)
Dim adapter As New SqlDataAdapter("SELECT * FROM Sales", connection)
adapter.Fill(dataTable)
End Using
' Build HTML table from data
Dim htmlBuilder As New StringBuilder()
htmlBuilder.Append("<h1>Sales Report</h1><table border='1'><tr>")
For Each column As DataColumn In dataTable.Columns
htmlBuilder.Append($"<th>{column.ColumnName}</th>")
Next
htmlBuilder.Append("</tr>")
For Each row As DataRow In dataTable.Rows
htmlBuilder.Append("<tr>")
For Each item In row.ItemArray
htmlBuilder.Append($"<td>{item}</td>")
Next
htmlBuilder.Append("</tr>")
Next
htmlBuilder.Append("</table>")
' Convert to PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString())
pdf.SaveAs("sales-report.pdf")
End Sub
End ClassSSRS erfordert eine vordesignte .rdlc-Berichtdatei ("SalesReport.rdlc"), das Ausfüllen einer DataSet, das Erstellen einer ReportDataSource mit einem bestimmten Namen ("SalesDataSet"), der mit der Berichtdefinition übereinstimmen muss, das Löschen bestehender Datenquellen, das Hinzufügen der neuen Datenquelle und dann das Rendern.
IronPDF verwendet Ihren vorhandenen Datenzugriffscode (gleiches SqlDataAdapter-Muster), dann baut es HTML dynamisch mit StringBuilder auf. Sie haben die volle Kontrolle über das Layout unter Verwendung von Standard-HTML/CSS - es sind keine proprietären Berichtsdefinitionsdateien erforderlich.
| Feature | SSRS | IronPDF |
|---|---|---|
| Infrastruktur : | ||
| SQL Server-Lizenz | Erforderlich | Nicht erforderlich |
| Windows-Server | Erforderlich | Jede Plattform |
| Datenbank erforderlich | Ja (ReportServer DB) | Nein |
| : Entwicklung : | ||
| Format der Vorlage | RDLC/RDL | HTML/CSS/Razor |
| Datenquellen | Eingebauter DSN | Alle C#-Daten |
| : Rendering : | ||
| URL zu PDF | Nein | Ja |
| CSS-Unterstützung | Beschränkt | Vollständig CSS3 |
| JavaScript | Nein | Vollständiger ES2024 |
| Diagramme | Eingebaut | Über JS-Bibliotheken |
| Bereitstellung : | ||
| Konfiguration | Komplex | Einfach |
| Wartung | Hoch | Niedrig |
SSRS: Verwendet das proprietäre XML-Format .rdlc.
Lösung: Konvertierung in HTML-Vorlagen:
SSRS: Verbindungszeichenfolgen in Report Server.
Lösung: Verwenden Sie die Datenzugriffsschicht Ihrer Anwendung:
var data = await _dbContext.Sales.ToListAsync();
// Then bind to HTML templateDim data = Await _dbContext.Sales.ToListAsync()
' Then bind to HTML templateSSRS: Eingebaute Parameteraufforderungen.
Lösung: Erstellen Sie Parameter UI in Ihrer Anwendung:
// Your own parameter form, then:
var pdf = GenerateReport(startDate, endDate, region);' Your own parameter form, then:
Dim pdf = GenerateReport(startDate, endDate, region)SSRS: Eingebautes Abonnement-System.
Lösung: Verwenden Sie das Framework für Hintergrundaufträge:
// Using Hangfire or similar
RecurringJob.AddOrUpdate("weekly-report",
() => GenerateAndEmailReport(), Cron.Weekly);net.rdlc-Dateien)IronPdf NuGet-Paket installieren.rdlc-Dateien in HTML-Vorlagen konvertierenLocalReport durch ChromePdfRendererReportDataSource mit C#-Daten + HTML-VorlagenReportParameter mit ZeichenketteninterpolationLocalReport.Render("PDF") durch RenderHtmlAsPdf()HtmlHeaderFooter
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.
