🚀 Dependency Injection in ASP.NET Core

Introduction

When building applications using ASP.NET Core, we often create objects inside classes.

Example:

ProductService service = new ProductService();

But this is not a good practice in large applications.

Why?

Because:

• Code becomes tightly coupled

• Hard to test

• Hard to maintain

• Difficult to scale

To solve this problem, ASP.NET Core uses:

Dependency Injection (DI)

In this article, we will learn:

• What is Dependency Injection?

• Why do we use it?

• How it works?

• Step-by-step example

• Output explanation

Everything in simple words.

What is Dependency Injection?

Dependency Injection means:

Instead of creating an object inside a class, we provide (inject) the object from outside.

Simple meaning:

“Don’t create dependency. Receive dependency.”

Why Use Dependency Injection?

Without DI:

• Classes depend on specific implementations

• Difficult to change code

• Hard to write unit tests

With DI:

• Loose coupling

• Easy testing

• Clean code

• Better maintainability

Real-Life Example

Think like this:

• A Car needs an Engine

• Instead of building the engine inside the car

• The engine is provided from outside

That is Dependency Injection.

Step-by-Step Example in ASP.NET Core

Step 1 – Create Interface

Create a folder: Services

Add Interface:

public interface IMessageService
{
    string GetMessage();
}

Step 2 – Create Service Class

public class MessageService : IMessageService
{
    public string GetMessage()
    {
        return "Hello from Dependency Injection!";
    }
}

Step 3 – Register Service in Program.cs

Open Program.cs:

builder.Services.AddScoped<IMessageService, MessageService>();

This tells ASP.NET Core:

• Whenever IMessageService is required

• Provide MessageService object

Step 4 – Use in Controller

using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    private readonly IMessageService _messageService;

    public HomeController(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public IActionResult Index()
    {
        var message = _messageService.GetMessage();
        ViewBag.Message = message;
        return View();
    }
}

Notice:

We did NOT create an object using new.

ASP.NET Core automatically injects it.

Step 5 – Create View

Index.cshtml:

<h2>@ViewBag.Message</h2>

Output

When you run the project:

https://localhost:xxxx/Home/Index

You will see:

Hello from Dependency Injection!

How Dependency Injection Works Internally

1. We register the service in Program.cs

2. ASP.NET Core creates the object automatically

3. It injects the object into the constructor

4. The controller uses the injected service

Types of Dependency Injection in ASP.NET Core

AddTransient

New object every time requested.

AddScoped

One object per request.

AddSingleton

One object for the entire application lifetime.

Difference Table

Type	Lifetime
Transient	New instance every time
Scoped	One per request
Singleton	One for entire application

When Should You Use DI?

Use Dependency Injection when:

• Working with services

• Connecting to a database

• Sending emails

• Logging

• Building large applications

Conclusion

In this article, we learned:

• What is Dependency Injection

• Why it is important

• How to implement it in ASP.NET Core

• Types of DI

• Example with output

Dependency Injection is one of the most important concepts in ASP.NET Core and is frequently asked in interviews.

If you understand DI clearly, your code becomes professional and scalable.

Summary

Dependency Injection in ASP.NET Core helps reduce tight coupling by injecting dependencies from outside instead of creating them inside classes. It improves testability, maintainability, and scalability. By registering services in Program.cs and using constructor injection, ASP.NET Core automatically manages object creation based on the configured lifetime (Transient, Scoped, or Singleton). Understanding DI is essential for building clean and professional applications.