How can you inject the service dependency into the controller?

Dependency Injection means giving a controller what it needs, instead of the controller creating it by itself. Let see how can do it using most recommended and simplest approach -Constructor Injection.

Step 1: Create a Service Interface

public interface IEmailService
{
    void Send(string message);
}

Step 2: Create the Service Implementation

public class EmailService : IEmailService
{
    public void Send(string message)
    {
        Console.WriteLine($"Email sent: {message}");
    }
}

Step 3: Register the Service (Program.cs)

In Progam.cs file, add this :

builder.Services.AddScoped();

Step 4: Inject the Service into the Controller

public class NotificationController : Controller
{
    private readonly IEmailService _emailService;

    public NotificationController(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public IActionResult Send()
    {
        _emailService.Send("Hello!");
        return Ok();
    }
}

What Just Happened?

1. Controller says:
   “I need an IEmailService”

2. .NET looks at registrations

3. Finds EmailService

4. Creates it

5. Passes it into the controller

You never used new EmailService() — that’s the key.

Hope this helps.

You can inject a service dependency into a controller using Dependency Injection (DI).
In ASP.NET / ASP.NET Core, this is done through constructor injection, which is the recommended and most common approach.

Step 1: Create a service interface

public interface IProductService
{
    List GetProducts();
}

Step 2: Implement the service

public class ProductService : IProductService
{
    public List GetProducts()
    {
        return new List { "Laptop", "Mobile", "Tablet" };
    }
}

Step 3: Register the service in the DI container

ASP.NET Core (.NET 6 / .NET 7 / .NET 8)

builder.Services.AddScoped();

(You can also use AddSingleton or AddTransient based on requirement.)

Step 4: Inject the service into the controller

public class ProductController : Controller
{
    private readonly IProductService _productService;

    public ProductController(IProductService productService)
    {
        _productService = productService;
    }

    public IActionResult Index()
    {
        var products = _productService.GetProducts();
        return View(products);
    }
}

How it works

• ASP.NET Core automatically creates the service object

• Injects it through the controller constructor

• Manages the service lifetime

Types of Dependency Injection

1. Constructor Injection (Recommended)

2. Property Injection

3. Method Injection

interview answer

Service dependency is injected into a controller by registering the service in the DI container and using constructor injection in the controller.

If you want, I can also explain:

• Scoped vs Transient vs Singleton

• DI in Web API vs MVC

• Unit testing with DI

https://www.tutorialspoint.com/how-can-we-inject-the-service-dependency-into-the-controller-chash-asp-net-core

You can do it following steps.

1.  First create your interface and it's implementation.

public interface IDateTime
{DateTime Now { get; }
}public class SystemDateTime : IDateTime
{public DateTime Now{get { return DateTime.Now; }}
}

2. Configure Service container

public void ConfigureServices(IServiceCollection services)
{services.AddSingleton();services.AddControllersWithViews();
}

3. Initiate into constructor of the controller where you want to call.

public class HomeController : Controller
{private readonly IDateTime _dateTime;public HomeController(IDateTime dateTime){_dateTime = dateTime;}public IActionResult Index(){var serverTime = _dateTime.Now;if (serverTime.Hour < 12){ViewData["Message"] = "It's morning here - Good Morning!";}else if (serverTime.Hour < 17){ViewData["Message"] = "It's afternoon here - Good Afternoon!";}else{ViewData["Message"] = "It's evening here - Good Evening!";}return View();}

That's it.

You can refer to Microsoft learn.

Hi Naresh,

You can use it here in different flavors, It's based on how you would like to set it up. Here we go the options are

• Constructor
• Method
• Property

To inject, you have to register in the startup class which eventually binds objects using the Inversion of Control principle.

ASP.NET Core injects objects of dependency classes through constructor or method by using built-in IoC container.

The built-in container is represented by IServiceProvider implementation that supports constructor injection by default. The types (classes) managed by built-in IoC container are called services.

In order to let the IoC container automatically inject our application services, we first need to register them with IoC container.

Example

public interface ILog{
   void info(string str);
}
class MyConsoleLogger : ILog{
   public void info(string str){
      Console.WriteLine(str);
   }
}

ASP.NET Core allows us to register our application services with IoC container, in the ConfigureServices method of the Startup class. The ConfigureServices method includes a parameter of IServiceCollection type which is used to register application services

Register ILog with IoC container in ConfigureServices() method as shown below.

public class Startup{
   public void ConfigureServices(IServiceCollection services){
      services.AddSingleton();
   }
}

Add() method of IServiceCollection instance is used to register a service with an IoC container

We have specified ILog as service type and MyConsoleLogger as its instance This will register ILog service as a singleton Now, an IoC container will create a singleton object of MyConsoleLogger class and inject it in the constructor of classes wherever we include ILog as a constructor or method parameter throughout the application.