Dependency Injection in ASP.NET Core: Practical Usage

In the previous article, we discussed how to register services in ASP.NET Core. Service registration is the first step of the dependency injection (DI) process; in this article, we’ll delve into how to actually use those registered services in practice.

What Is Dependency Injection?

Dependency injection is a design pattern that moves an object’s dependencies from inside the object itself to the outside. In ASP.NET Core, dependency injection reduces coupling between components, thereby improving code testability and flexibility.

Before using dependency injection, ensure you’ve already registered your services. For example, in the previous article, we registered a simple IMyService interface and its implementation MyService, as shown below:

public interface IMyService
{
    string GetGreeting();
}

public class MyService : IMyService
{
    public string GetGreeting() => "Hello from MyService!";
}

The code above defines a simple service interface and its implementation.

Using Dependency Injection

Using dependency injection in ASP.NET Core is straightforward—you simply request the required service where it’s needed. Typically, this occurs in controllers, Razor Pages, or middleware.

1. Using Dependency Injection in Controllers

Here’s an example controller that uses the IMyService service:

using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    private readonly IMyService _myService;

    public HomeController(IMyService myService)
    {
        _myService = myService;
    }

    public IActionResult Index()
    {
        var greeting = _myService.GetGreeting();
        ViewData["Greeting"] = greeting;
        return View();
    }
}

In the code above, the IMyService instance is injected via the constructor of HomeController and assigned to the private field _myService. Then, within the Index action method, we use this service to retrieve a greeting message.

2. Using Dependency Injection in Razor Pages

Similar to controllers, you can also inject dependencies into Razor Pages. For example, modify Index.cshtml.cs as follows:

using Microsoft.AspNetCore.Mvc.RazorPages;

public class IndexModel : PageModel
{
    private readonly IMyService _myService;

    public string Greeting { get; private set; }

    public IndexModel(IMyService myService)
    {
        _myService = myService;
    }

    public void OnGet()
    {
        Greeting = _myService.GetGreeting();
    }
}

Here, IMyService is injected via the constructor of IndexModel, and then invoked in the OnGet handler to supply data.

Testing Dependency Injection

Another major benefit of dependency injection is simplified unit testing. Below is a simple test for HomeController:

using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;

public class HomeControllerTests
{
    [Fact]
    public void Index_ReturnsViewWithGreeting()
    {
        // Arrange
        var mockService = new Mock<IMyService>();
        mockService.Setup(s => s.GetGreeting()).Returns("Test Greeting");
        var controller = new HomeController(mockService.Object);

        // Act
        var result = controller.Index() as ViewResult;

        // Assert
        Assert.NotNull(result);
        Assert.Equal("Test Greeting", result.ViewData["Greeting"]);
    }
}

In this test, we use the Moq library to create a mock instance of IMyService. This ensures the test doesn’t rely on the real service implementation—improving test isolation and stability.

Summary

In this article, we explored how to practically use dependency injection in ASP.NET Core applications. Starting with examples in controllers and Razor Pages, we demonstrated how to obtain and consume services via constructor injection. By adopting dependency injection, we significantly enhance code maintainability and testability.

In the next article, we’ll continue by exploring how to perform data access using Entity Framework Core—stay tuned!