Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

Home Interviews Thought about DI in asp.net Core? – MindStick
Ask Question

1 Answers

Anubhav Sharma
Anubhav Sharma 29 Mar 2026
Report Abuse

Dependency Injection (DI) in ASP.NET Core is a core design pattern used to decouple components, improve testability, and make your application maintainable and scalable.

What is Dependency Injection?

Dependency Injection means:

Instead of a class creating its own dependencies, those dependencies are provided (injected) from outside.

Without DI (Bad Practice)

public class ArticleService
{
    private readonly SqlRepository _repo;

    public ArticleService()
    {
        _repo = new SqlRepository(); // tightly coupled
    }
}

Problems:

  • Hard to test
  • Hard to replace implementation
  • Tight coupling

With DI (Good Practice)

public class ArticleService
{
    private readonly IRepository _repo;

    public ArticleService(IRepository repo)
    {
        _repo = repo; // injected
    }
}

Built-in DI in ASP.NET Core

Unlike old ASP.NET MVC, ASP.NET Core has DI built-in.

You configure it in:

Program.cs

Step 1: Register Services

builder.Services.AddScoped<IRepository, SqlRepository>();
builder.Services.AddScoped<IArticleService, ArticleService>();

Step 2: Use in Controller

public class ArticleController : Controller
{
    private readonly IArticleService _service;

    public ArticleController(IArticleService service)
    {
        _service = service;
    }
}

ASP.NET Core automatically injects it.

Service Lifetimes (Very Important)

1. Transient

AddTransient<IService, Service>();

New instance every time

2. Scoped (Most used)

AddScoped<IService, Service>();

One instance per request

3. Singleton

AddSingleton<IService, Service>();

One instance for entire app

Which one should YOU use?

Based on your project:

Use Case Lifetime
DB Context / Repository Scoped
Business Services Scoped
Utility (stateless) Singleton
Lightweight helper Transient

Why DI is Important (Real Benefits)

1. Loose Coupling

You can switch:

SqlRepository → MongoRepository

without changing business logic

2. Testability

You can inject mock:

var mockRepo = new Mock<IRepository>();

3. Better Performance Control

With proper lifetime:

  • Avoid memory leaks
  • Avoid unnecessary object creation

4. Clean Architecture

Supports:

  • Repository Pattern
  • Service Layer
  • Unit of Work

DI in ASP.NET Core =
“Framework automatically provides required objects to your classes instead of you creating them manually.”

MindStick Training
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md