La migration de SQL Server Reporting Services (SSRS) vers IronPDF transforme votre flux de production de PDF d'une infrastructure lourde basée sur un serveur à une bibliothèque légère, en cours de processus, qui peut être intégrée directement dans n'importe quelle application .NET. Ce guide fournit un chemin de migration complet, étape par étape, qui élimine les dépendances de SQL Server, la surcharge du serveur de rapports et l'enfermement dans l'écosystème Microsoft.
SQL Server Reporting Services (SSRS) est la plateforme de reporting d'entreprise de Microsoft — un ensemble complet pour créer, déployer et gérer des rapports, étroitement intégré à l'écosystème SQL Server. Microsoft a confirmé que SSRS 2022 est la dernière version autonome : à partir de SQL Server 2025, le reporting sur site est consolidé dans Power BI Report Server (PBIRS), et aucune nouvelle version de SSRS ne sera livrée. SSRS 2022 reçoit des mises à jour de sécurité jusqu'au 11 janvier 2033, conformément au cycle de vie de SQL Server 2022 (voir la FAQ sur la consolidation des services de reporting).
Dans de nombreux scénarios de génération de PDF, l'infrastructure SSRS est excessive. Les principales raisons de migrer incluent :
Microsoft.ReportingServices.ReportViewerControl.WebForms / .Winforms ciblent uniquement .NET Framework 4.0–4.8.1. Les utilisateurs de .NET Core / .NET 5+ dépendent du port communautaire ReportViewerCore.NETCore.| Votre besoin | Frais généraux SSRS |
|---|---|
| Générer des factures | Serveur de rapport complet |
| Exporter des tableaux de données | Licence SQL Server |
| Créer des PDF à partir de données | Serveur Windows |
| Génération de documents simples | Abonnements aux rapports |
IronPDF permet de générer des PDF en cours de processus, sans aucune infrastructure de serveur.
| Fonction | SSRS | IronPDF |
|---|---|---|
| Dépendance | Requiert SQL Server | Pas de dépendance spécifique à l'égard d'une base de données |
| Déploiement | Basé sur le serveur | Bibliothèque (intégrée dans les applications) |
| Intégration | Intégration étroite avec Microsoft | Fonctionne avec n'importe quelle source de données |
| Visualisation des données | Options natives étendues | Visualisations axées sur les PDF |
| Complexité | Haut (configuration du serveur requise) | Modéré à faible (configuration de la bibliothèque) |
| Coût | Coût des licences SQL Server | Coût de la licence par développeur |
| HTML à PDF | Non | Chromium complet |
| URL vers PDF | Non | Oui |
| Support CSS | Limité | CSS3 complet |
| JavaScript | Non | ES2024 complet |
IronPDF, contrairement à SSRS, n'est pas lié à une base de données ou à un écosystème de serveur spécifique. Il fournit aux développeurs une bibliothèque flexible pour créer, éditer et manipuler dynamiquement des documents PDF directement en C#. Ce découplage par rapport à une infrastructure basée sur un serveur offre un avantage notable : il est simple et adaptable, et convient à un large éventail d'applications au-delà de la production de rapports.
Pour les équipes adoptant le .NET moderne, IronPDF fournit un moteur de rendu Chromium qui élimine la complexité de l'infrastructure SSRS.
# 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| Concept SSRS | Équivalent d'IronPDF | Notes |
|---|---|---|
LocalReport | ChromePdfRenderer | Rendu de base |
ServerReport | RenderUrlAsPdf() | Rendu basé sur l'URL |
.rdlc fichiers | Modèles HTML/CSS | Format du modèle |
ReportParameter | Interpolation de chaînes de caractères | Paramètres |
ReportDataSource | Données C# + HTML | Liaison de données |
LocalReport.Render("PDF") | RenderHtmlAsPdf() | Sortie PDF |
SubReport | PDF fusionnés | Rapports imbriqués |
Report Server URL | Pas nécessaire | Aucun serveur n'est nécessaire |
ReportViewer contrôle | Pas nécessaire | Génération directe de PDF |
| Formats d'exportation | Le PDF est natif | Un résultat ciblé |
Avant (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 ClassAprès (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 ModuleCet exemple illustre la différence architecturale fondamentale. SSRS nécessite la création d'une instance ReportViewer, le chargement d'un fichier de définition de rapport .rdlc, la définition de paramètres, puis l'appel de LocalReport.Render("PDF") avec plusieurs paramètres out pour les métadonnées.
IronPDF utilise un ChromePdfRenderer avec RenderHtmlAsPdf() en seulement trois lignes de code. Aucun fichier de définition de rapport, aucun objet de paramètre, aucune manipulation de métadonnées n'est requise. Consultez la documentation HTML vers PDF pour des exemples complets.
Avant (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 ClassAprès (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 ne peut pas convertir directement les URL en PDF. Vous devez télécharger manuellement le contenu HTML avec WebClient.DownloadString(), créer un fichier de rapport .rdlc séparé, passer le texte HTML et en-tête/pied de page sous forme de tableaux ReportParameter, puis rendre avec la signature de méthode complexe Render().
Le RenderUrlAsPdf() de IronPDF gère tout le processus en un seul appel. Les en-têtes et pieds de page sont configurés avec des objets HtmlHeaderFooter qui supportent le HTML/CSS complet et des espaces réservés tels que {page} et {total-pages}. Pour en savoir plus, consultez nos tutoriels.
Avant (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 ClassAprès (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 nécessite un fichier de rapport préconçu .rdlc ("SalesReport.rdlc"), le remplissage d'un DataSet, la création d'un ReportDataSource avec un nom spécifique ("SalesDataSet") qui doit correspondre à la définition du rapport, la suppression des sources de données existantes, l'ajout de la nouvelle source de données, puis le rendu.
IronPDF utilise votre code d'accès aux données existant (même modèle SqlDataAdapter), puis construit dynamiquement le HTML avec StringBuilder. Vous avez un contrôle total sur la mise en page à l'aide de HTML/CSS standard - aucun fichier de définition de rapport propriétaire n'est requis.
| Fonction | SSRS | IronPDF |
|---|---|---|
| : Infrastructure : | ||
| Licence SQL Server | Les exigences sont les suivantes | Pas nécessaire |
| Serveur Windows | Les exigences sont les suivantes | Toutes les plates-formes |
| Base de données requise | Oui (ReportServer DB) | Non |
| : Développement : | ||
| Format du modèle | RDLC/RDL | HTML/CSS/Razor |
| Sources de données | DSN intégré | Toutes les données C# |
| : Rendu : | ||
| URL vers PDF | Non | Oui |
| Support CSS | Limité | CSS3 complet |
| JavaScript | Non | ES2024 complet |
| Graphiques | Intégré | Via les bibliothèques JS |
| : Déploiement : | ||
| Configuration | Complexe | Simple |
| Entretien | Haut | Faible |
SSRS: Utilise le format XML propriétaire .rdlc.
Solution: Convertir en modèles HTML :
**SSRS:**Chaînes de connexion dans Report Server.
Solution: Utilisez la couche d'accès aux données de votre application :
var data = await _dbContext.Sales.ToListAsync();
// Then bind to HTML templateDim data = Await _dbContext.Sales.ToListAsync()
' Then bind to HTML template**SSRS:**Intégration d'invites de paramètres.
Solution: Construisez une interface utilisateur paramétrée dans votre application :
// Your own parameter form, then:
var pdf = GenerateReport(startDate, endDate, region);' Your own parameter form, then:
Dim pdf = GenerateReport(startDate, endDate, region)SSRS: Moteur d'abonnement intégré.
Solution: Utiliser un cadre de travail en arrière-plan :
// Using Hangfire or similar
RecurringJob.AddOrUpdate("weekly-report",
() => GenerateAndEmailReport(), Cron.Weekly);net.rdlc)IronPdf.rdlc en modèles HTMLLocalReport par ChromePdfRendererReportDataSource par des données C# + modèles HTMLReportParameter par une interpolation de chaînesLocalReport.Render("PDF") par RenderHtmlAsPdf()HtmlHeaderFooter
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
