Made withASP.NET CoreClip

Adding a Service to an ASP.NET Core Website | ASP.NET Core 101 [4 of 13]

D

dotnet

Creator on the ASP.NET Core channel

Watch on YouTube ↗

265K viewsSep 23, 201913:21 runtime

Learn to structure your ASP.NET Core applications for maintainability by creating a dedicated service to handle data retrieval. This guide walks through the entire process, explaining the single responsibility principle and how to implement it. You'll see how to create a…

Chapters

#aspnetcore#clip#frameworks

Why Use a Service?

A service is a component that performs a specific task for other parts of the application. Using services helps create more maintainable and reusable code.

Single Responsibility Principle: Each part of the application should have only one job. The service's job is to retrieve product data, separating that concern from the web page that displays it.
Maintainability: If the data source changes (e.g., from a JSON file to a database), you only need to update the service, not every page that uses the data.
Reusability: Other parts of the application can easily use the same service to get product data.

Note
A service is like a waiter in a restaurant: you ask for what you need, and the waiter gets it for you without you needing to know how the kitchen works.

Creating the `JsonFileProductService`

Create a services folder in the root of the project to organize your service classes.
Add a new C# class file named JsonFileProductService.cs inside the a services folder.

Understanding the Service Code

The JsonFileProductService class is responsible for reading and parsing the products.json file.

The Constructor and `IWebHostEnvironment`

The constructor receives an IWebHostEnvironment object via dependency injection. ASP.NET automatically provides this service.

public JsonFileProductService(IWebHostEnvironment webHostEnvironment)
{
    WebHostEnvironment = webHostEnvironment;
}

This is used to get reliable information about the web application's hosting environment, such as file paths.

Building the File Path

To avoid hardcoding file paths (e.g., C:\...), the service builds the path dynamically.

WebHostEnvironment.WebRootPath: This property reliably gets the absolute path to the wwwroot folder, which is designed to contain public, static assets.
System.IO.Path.Combine(): This helper method safely combines path segments, handling path separators (/ or \) correctly for any operating system.

private string JsonFileName
{
    get { return Path.Combine(WebHostEnvironment.WebRootPath, "data", "products.json"); }
}

The `GetProducts` Method

This method reads the JSON file, deserializes it into C# objects, and returns them.

Deserialization: It uses System.Text.Json.JsonSerializer.Deserialize to convert the JSON text into an array of Product objects (Product[]).
Case Insensitivity: It passes an option to the deserializer to ignore differences in case between the JSON properties and the C# model properties (PropertyNameCaseInsensitive = true).
IEnumerable<Product>: The method returns an IEnumerable<Product>. This is a flexible, read-only collection interface that allows the caller to iterate over the products without being tied to a specific collection type like a List or an array.

Registering the Service (Dependency Injection)

For the rest of the application to be able to use the service, it must be "registered" in the Startup.cs file.

ConfigureServices(IServiceCollection services): This method in Startup.cs is where you configure your application's services.
services.AddTransient<JsonFileProductService>(): This line registers the service with the dependency injection (DI) container.

Important
Service Lifetimes:

AddTransient(): A new instance of the service is created every time it's requested. This is useful for lightweight, stateless services.

AddSingleton(): A single instance is created for the entire application's lifetime.