SQL SSRS Report in ASP.NET Core: A Beginner’s Guide

Post 21 hours ago - | | 28

1. What is SSRS?

What?

SSRS stands for SQL Server Reporting Services.

It is a Microsoft reporting platform used to create, manage, and deliver reports using data from databases and other data sources.

For example, suppose you have an application that stores customer orders in SQL Server.

You might want a report like:

Order ID Customer Order Date Amount
1001 John 01-Sep-2026 $500
1002 Sarah 02-Sep-2026 $750
1003 David 02-Sep-2026 $320

Instead of writing all the reporting logic yourself, you can create an SSRS report that retrieves and formats this data.

Why?

SSRS is useful when you need:

  • Printable reports
  • PDF reports
  • Excel exports
  • Parameterized reports
  • Tables and charts
  • Grouping and summaries
  • Page headers and footers
  • Scheduled reports
  • Business/financial reports

How?

SSRS generally works like this:

SQL Server
    ↓
SQL Query / Stored Procedure
    ↓
SSRS Report (.rdl)
    ↓
SSRS Report Server
    ↓
ASP.NET Core Application
    ↓
User

The important thing to understand is that ASP.NET Core does not replace SSRS.

ASP.NET Core is your web application, while SSRS is responsible for generating and managing the report.

2. What is an SSRS Report?

What?

An SSRS report is usually represented by an .rdl file.

RDL means Report Definition Language.

Think of an .rdl file as the blueprint of your report.

It contains information such as:

  • Which data source to use
  • Which query to execute
  • Which columns to display
  • Report parameters
  • Tables
  • Charts
  • Formatting
  • Grouping
  • Page layout

For example:

SalesReport.rdl

might define a report containing:

Customer
Order Date
Product
Quantity
Total Amount

Why?

Separating the report definition from your application makes reports easier to design and maintain.

You can change the report layout without rewriting your entire ASP.NET Core application.

How?

You typically create an RDL file using a reporting designer such as Microsoft Report Builder or SQL Server Data Tools (SSDT).

3. What is Report Builder?

What?

Report Builder is a Microsoft tool for designing SSRS reports.

It provides a visual interface where you can create:

  • Tables
  • Charts
  • Text boxes
  • Parameters
  • Groups
  • Filters
  • Headers
  • Footers

You don't have to manually write the RDL XML.

Why?

As a beginner, manually creating RDL files would be unnecessarily difficult.

Report Builder lets you visually design the report.

For example:

+---------------------------------------+
|          SALES REPORT                 |
+---------------------------------------+
| Customer | Date       | Amount        |
+---------------------------------------+
| John     | 01-Sep     | $500          |
| Sarah    | 02-Sep     | $750          |
+---------------------------------------+
| Total                    $1,250       |
+---------------------------------------+

How?

You generally:

  • Install/open Report Builder.
  • Create a new report.
  • Create a data source.
  • Create a dataset.
  • Add a table or other report item.
  • Select the fields you want to display.
  • Add parameters if required.
  • Format the report.
  • Save the report as an .rdl file.
  • Deploy/upload it to the SSRS Report Server.

4. What is a Report Server?

What?

An SSRS Report Server is the server that hosts your SSRS reports.

For example:

https://your-server/ReportServer

The exact URL depends on how SSRS was installed and configured.

The Report Server stores and executes your reports.

Why?

Without a report server, you don't have the normal SSRS environment for hosting and executing server-based SSRS reports.

The server can manage:

  • Reports
  • Data sources
  • Report parameters
  • Security
  • Report execution
  • Subscriptions
  • Report history
  • Caching

How?

A typical setup looks like:

                SQL Server
                    ↑
                    |
              SSRS Report Server
                    ↑
                    |
             ASP.NET Core App
                    ↑
                    |
                  User

5. What is a Data Source?

What?

A data source tells SSRS where the report's data comes from.

For example, your data source could point to SQL Server.

Conceptually:

Server: MySqlServer
Database: SalesDB
Authentication: SQL/Windows

Why?

SSRS needs to know where it should retrieve the data.

Without a data source, your report doesn't know where the customer/order information is located.

How?

In Report Builder, you can create a data source and configure the SQL Server connection.

For example:

Data Source Name:
SalesDatabase

Database:
SalesDB

6. What is a Dataset?

This is one of the most important concepts for SSRS beginners.

What?

  • A dataset defines the data that your report uses.
  • A data source tells SSRS where the database is.
  • A dataset tells SSRS what data to retrieve.

Think of it this way:

Data Source
     ↓
Where is the database?

Dataset
     ↓
What data do I want?

Why?

Your report needs a specific set of records to display.

For example, you might create a dataset using:

SELECT
    OrderId,
    CustomerName,
    OrderDate,
    TotalAmount
FROM Orders;

How?

In Report Builder:

Report
  ↓
Dataset
  ↓
SQL Query
  ↓
SQL Server
  ↓
Records

The resulting fields might be:

OrderId
CustomerName
OrderDate
TotalAmount

You can then drag those fields into your report table.

7. What is a Stored Procedure in SSRS?

What?

Instead of writing a SQL query directly in the SSRS dataset, you can use a stored procedure.

For example:

CREATE PROCEDURE GetSalesReport
    @StartDate DATE,
    @EndDate DATE
AS
BEGIN

    SELECT
        OrderId,
        CustomerName,
        OrderDate,
        TotalAmount
    FROM Orders
    WHERE OrderDate BETWEEN @StartDate AND @EndDate;

END

SSRS can execute this stored procedure and use the returned data in the report.

Why?

Stored procedures are useful when:

  • The query is complex
  • You want centralized SQL logic
  • You need parameters
  • Multiple applications use the same reporting logic
  • You want database-side control over the query

How?

Your SSRS dataset can be configured to execute:

GetSalesReport

with parameters such as:

@StartDate
@EndDate

8. What are SSRS Parameters?

What?

Parameters allow users to provide values to a report.

For example:

Start Date: 01-Sep-2026
End Date:   30-Sep-2026

The report can then display only the records for that date range.

Why?

Without parameters, your report might always show every record in the database.

Parameters make reports dynamic.

For example:

Customer Report

Customer:
[ John ▼ ]

Start Date:
[ 01-Sep-2026 ]

End Date:
[ 30-Sep-2026 ]

        [ View Report ]

How?

Suppose your SQL query is:

SELECT *
FROM Orders
WHERE OrderDate BETWEEN @StartDate AND @EndDate;

You create two SSRS report parameters:

StartDate
EndDate

SSRS passes those values to the dataset query.

9. What is the relationship between ASP.NET Core and SSRS?

This is where beginners often get confused.

What?

  • ASP.NET Core and SSRS are two different technologies.
  • ASP.NET Core is used to build your web application.
  • SSRS is used to generate and manage reports.
  • They can work together.

Why?

Suppose your ASP.NET Core application has this page:

Sales Dashboard

Start Date: [01-Sep-2026]
End Date:   [30-Sep-2026]

[ Generate Report ]

When the user clicks Generate Report, your application can request the SSRS report.

Conceptually:

Browser
   ↓
ASP.NET Core
   ↓
SSRS
   ↓
SQL Server
   ↓
SSRS generates report
   ↓
ASP.NET Core / Browser

10. Can ASP.NET Core directly run an RDL file?

What?

An .rdl file is a report definition. Simply putting an RDL file inside your ASP.NET Core project does not automatically make ASP.NET Core understand and render it.

Why?

RDL is designed for the SSRS reporting environment.

The report normally needs a reporting engine/server capable of processing it.

How?

A common architecture is:

ASP.NET Core
       |
       | Request report
       ↓
SSRS Report Server
       |
       | Execute report
       ↓
SQL Server

ASP.NET Core can then provide the report to the browser or use the generated report output as appropriate.

11. How do I create an SSRS report?

Let's look at the complete beginner workflow.

Step 1: Create your SQL table

For example:

CREATE TABLE Employees
(
    Id INT,
    Name VARCHAR(100),
    Department VARCHAR(100),
    Salary DECIMAL(18,2)
);

Insert some data:

INSERT INTO Employees
VALUES
(1, 'John', 'IT', 50000),
(2, 'Sarah', 'HR', 45000),
(3, 'David', 'Finance', 60000);

Step 2: Create a report

Open Report Builder and create a new report.

Give it a name such as:

EmployeeReport.rdl

Step 3: Create a data source

Configure your SQL Server connection.

For example:

Server: MyServer
Database: CompanyDB

Step 4: Create a dataset

Use:

SELECT
    Id,
    Name,
    Department,
    Salary
FROM Employees;

Step 5: Add a table

Add a table to the report.

Your table could look like:

+----+--------+------------+--------+
| ID | Name   | Department | Salary |
+----+--------+------------+--------+
| 1  | John   | IT         | 50000  |
| 2  | Sarah  | HR         | 45000  |
| 3  | David  | Finance    | 60000  |
+----+--------+------------+--------+

Step 6: Preview

Click Preview.

SSRS executes your dataset query and displays the report.

Step 7: Deploy the report

Upload/deploy the .rdl file to your SSRS Report Server.

Now your report is available on the server.

12. How does ASP.NET Core call the SSRS report?

There are several approaches, depending on your SSRS setup and the experience you want to provide.

A common approach is to use the SSRS report server's URL and pass report parameters.

Conceptually:

https://server/ReportServer?
/Reports/EmployeeReport
&rs:Format=PDF

Parameters can also be supplied.

For example:

StartDate=2026-09-01
EndDate=2026-09-30

The exact URL and authentication approach depends on your SSRS configuration.

Important

Don't assume that every SSRS installation uses the same URL, authentication mechanism, or embedding configuration. These are environment-specific.

13. What does rs:Format=PDF mean?

What?

SSRS supports different output formats.

For example:

PDF
Excel
Word
CSV
HTML

A report request can specify an output format.

Conceptually:

&rs:Format=PDF

means:

Generate the report as PDF.

Why?

Suppose your ASP.NET Core application has a button:

[ Download PDF ]

Your application can request the report in PDF format.

14. How can I display the SSRS report in ASP.NET Core?

There are different ways to integrate reports.

Option 1: Open the SSRS report

Your ASP.NET Core application can provide a link/button that opens the report on the SSRS server.

For example:

[ View Sales Report ]

The user is redirected to the report.

Advantage

Simple to implement.

Disadvantage

The user may leave your application's UI.

15. What about embedding the report?

What?

You can integrate the report experience into your application's interface, depending on your SSRS configuration and authentication setup.

Conceptually:

+----------------------------------------+
|       My ASP.NET Core Application      |
|                                        |
| Start Date: [01-Sep]                   |
| End Date:   [30-Sep]                   |
|                                        |
| +------------------------------------+ |
| |            SSRS Report             | |
| |                                    | |
| | Customer | Date | Amount           | |
| | John     | ...  | $500             | |
| +------------------------------------+ |
+----------------------------------------+

Why?

This gives users a more seamless experience.

They don't necessarily need to navigate to a separate reporting application.

How?

The implementation depends on your SSRS version, authentication configuration, deployment model, and whether you're using a server-hosted report viewer or generating report output through the server.

For ASP.NET Core, avoid assuming that older ASP.NET Framework ReportViewer examples will work unchanged. Many older tutorials were written for the classic .NET Framework ecosystem.

16. What is ReportViewer?

What?

ReportViewer is a Microsoft reporting component historically used to display SSRS or local reports in .NET applications.

You may find many tutorials showing code such as:

ReportViewer reportViewer = new ReportViewer();

Why is this confusing?

A large amount of SSRS documentation and sample code on the internet targets:

ASP.NET MVC
ASP.NET Web Forms
.NET Framework

rather than modern:

ASP.NET Core
.NET 6+
.NET 8+
.NET 9+

Therefore, you should check whether a particular ReportViewer library actually supports your target ASP.NET Core/.NET version before adopting it.

Beginner advice

Don't start by searching for:

"How to put ReportViewer in ASP.NET Core"

and blindly copying an old tutorial.

First understand the architecture:

ASP.NET Core
      ↓
SSRS Report Server
      ↓
SQL Server

Then choose the integration method that matches your environment.

17. How do report parameters flow from ASP.NET Core to SSRS?

Suppose your report has:

CustomerId

The user selects:

CustomerId = 10

The flow is:

User
 ↓
ASP.NET Core
 ↓
CustomerId = 10
 ↓
SSRS
 ↓
Dataset
 ↓
SQL Server

Your dataset might contain:

SELECT *
FROM Orders
WHERE CustomerId = @CustomerId;

SSRS receives:

CustomerId = 10

and executes the query.

18. What is the difference between an SSRS Parameter and a SQL Parameter?

This distinction is important.

SSRS Report Parameter

This is a parameter defined at the report level.

Example:

StartDate
EndDate

SQL Query Parameter

This is a parameter used by the SQL query.

Example:

WHERE OrderDate BETWEEN @StartDate AND @EndDate

SSRS connects the two.

Conceptually:

Report Parameter
       ↓
Dataset Parameter
       ↓
SQL Parameter
       ↓
SQL Server

19. How do I add a PDF download button?

Imagine your ASP.NET Core page has:

[ Generate Report ]

[ Download PDF ]

The basic concept is:

Browser
   ↓
ASP.NET Core Controller
   ↓
Request SSRS report as PDF
   ↓
SSRS
   ↓
PDF bytes
   ↓
ASP.NET Core
   ↓
Browser downloads PDF

Your ASP.NET Core controller can return the generated file to the browser.

Conceptually, the result is:

return File(pdfBytes, "application/pdf", "SalesReport.pdf");

The exact implementation for obtaining pdfBytes depends on how your SSRS server is configured and how you authenticate to it.

20. Can SSRS export to Excel?

What?

Yes. SSRS reports can support several export formats, depending on the report/server configuration.

Common formats include:

PDF
Excel
Word
CSV
XML
HTML

Why?

Different users need different formats.

For example:

Manager → PDF
Accountant → Excel
Developer → CSV

How?

Your application can request the appropriate report format from SSRS.

21. What is Report Parameter vs Filter?

Beginners often confuse these two.

Parameter

A parameter receives a value from the user or application.

Example:

Department = IT

The dataset can then retrieve only IT employees.

Filter

A filter can restrict data after the dataset has been retrieved.

For example:

Dataset:
1000 employees

Report Filter:
Department = IT

Displayed:
150 employees

Which should you use?

For large datasets, filtering in the SQL query is often preferable because it can reduce the amount of data retrieved from the database.

For example:

SELECT *
FROM Employees
WHERE Department = @Department;

is generally more efficient than retrieving every employee and filtering them only at the report level.

22. What are Groups in SSRS?

What?

Groups allow you to organize report data.

Suppose you have:

IT
  John
  David

HR
  Sarah
  Mike

Finance
  Robert

You can create a Department group.

Why?

Groups are useful for:

  • Department-wise reports
  • Customer-wise reports
  • Region-wise reports
  • Monthly reports
  • Category-wise reports

How?

You create a group based on a field.

For example:

Group by:
Department

SSRS then organizes records according to the department.

23. What are SSRS Expressions?

What?

Expressions allow you to calculate or dynamically display values in an SSRS report.

For example:

=Sum(Fields!Salary.Value)

calculates the total salary.

Another example:

=Count(Fields!Id.Value)

counts records.

Why?

Expressions are useful for:

  • Totals
  • Counts
  • Conditional formatting
  • Dynamic text
  • Date formatting
  • Calculations

For example:

Total Salary: $155,000

can be calculated dynamically.

24. What are Subreports?

What?

A subreport is a report embedded inside another report.

For example:

Customer Report
│
├── Customer: John
│
└── Order Details
      ├── Order 1001
      ├── Order 1002
      └── Order 1003

Why?

  • Subreports are useful when you need separate report sections or reusable report components.
  • However, they can increase complexity and sometimes affect performance.
  • As a beginner, start with normal datasets and grouping before introducing subreports.

25. What is a Shared Data Source?

What?

A shared data source is a reusable database connection that multiple reports can use.

For example:

SalesReport
InventoryReport
CustomerReport
EmployeeReport

could all use:

CompanyDatabase

Why?

Instead of configuring the database connection separately for every report, you can reuse the same data source.

This makes administration easier.

26. What is a Shared Dataset?

What?

A shared dataset is a reusable dataset that can be used by multiple reports.

Why?

Suppose many reports need the same list:

Department

Instead of creating the same query repeatedly, you can create a shared dataset.

27. How does the complete architecture work?

Let's put everything together.

Imagine an employee salary report.

User

The user selects:

Department: IT

ASP.NET Core

Your application receives:

Department = IT

SSRS

The report receives:

Department = IT

Dataset

The dataset executes:

SELECT
    Name,
    Department,
    Salary
FROM Employees
WHERE Department = @Department;

SQL Server

SQL Server returns:

John    IT    50000
David   IT    60000

SSRS

SSRS formats the results:

Employee Salary Report

Department: IT

+--------+--------+
| Name   | Salary |
+--------+--------+
| John   | 50000  |
| David  | 60000  |
+--------+--------+

Total: 110000

ASP.NET Core

Your application displays or downloads the generated report.

The complete flow is:

             User
               |
               ↓
       ASP.NET Core App
               |
               ↓
        SSRS Report Server
               |
               ↓
          Dataset
               |
               ↓
          SQL Server
               |
               ↓
        Report Results
               |
               ↓
       ASP.NET Core / User

28. Common mistakes beginners make

Mistake 1: Thinking SSRS is part of ASP.NET Core

It isn't.

They are separate technologies that can work together.

Mistake 2: Thinking an RDL file can simply be displayed by a browser

An RDL file is a report definition, not the final HTML/PDF report.

It needs a reporting engine/server to process it.

Mistake 3: Copying old ReportViewer tutorials

Many tutorials target older .NET Framework applications.

Always check whether the library and approach support your ASP.NET Core and .NET version.

Mistake 4: Putting too much logic into the report

If your SQL query is extremely complicated, consider whether the data preparation belongs in SQL/stored procedures or another application/data layer rather than becoming a giant collection of SSRS expressions.

Mistake 5: Retrieving huge datasets

Don't retrieve millions of rows and expect SSRS to filter everything efficiently.

Whenever possible, filter data at the database level.

For example:

WHERE OrderDate BETWEEN @StartDate AND @EndDate

is generally preferable to retrieving the entire Orders table.

29. Recommended learning path for an SSRS beginner

If you are completely new to SSRS, don't start with ASP.NET Core integration.

Learn SSRS first.

Follow this order:

1. SQL basics
      ↓
2. SSRS basics
      ↓
3. Data Sources
      ↓
4. Datasets
      ↓
5. Tables
      ↓
6. Parameters
      ↓
7. Expressions
      ↓
8. Groups
      ↓
9. Charts
      ↓
10. Exporting
      ↓
11. Report Server
      ↓
12. ASP.NET Core integration

This makes the learning process much easier.

30. Final understanding

If you remember only one thing from this article, remember this:

SQL Server stores the data, SSRS generates the report, and ASP.NET Core provides the application experience around that report.

Think of the responsibilities like this:

Technology Main Responsibility
SQL Server Stores and retrieves data
SQL Query/Stored Procedure Defines what data to retrieve
SSRS Designs and generates reports
RDL Defines the report structure
Report Server Hosts and executes reports
ASP.NET Core Provides the web application/UI
Browser Displays or downloads the result

The overall process is:

                 SQL Server
                     ↑
                     |
              Query / Procedure
                     ↑
                     |
                SSRS Dataset
                     ↑
                     |
                 SSRS Report
                   (.rdl)
                     ↑
                     |
              SSRS Report Server
                     ↑
                     |
              ASP.NET Core
                     ↑
                     |
                  Browser

Once you understand this architecture, SSRS becomes much less intimidating.

The best way to learn it is to first create a simple Employee Report, then add a Department parameter, then add grouping and totals, and finally connect that report to an ASP.NET Core application.

SSRS
Yogendra Mohan
Yogendra Mohan
0 Comments Report