Dependency Injection in ASP.NET Core

1. Register Services in Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddScoped<IProductService, ProductService>();
builder.Services.AddDbContext<AppDbContext>(opt => 
    opt.UseSqlite(builder.Configuration.GetConnectionString("Default")));

var app = builder.Build();

2. Service Lifetimes - Pick the Right One

3. Constructor Injection

public class ProductsController : Controller
{
    private readonly IProductService _service;
    private readonly AppDbContext _db;

    public ProductsController(IProductService service, AppDbContext db)
    {
        _service = service; // ASP.NET injects these
        _db = db;
    }

    public async Task<IActionResult> Index()
    {
        var products = await _service.GetAllAsync();
        return View(products);
    }
}

4. Why DI Matters

• Testable: Mock IProductService in unit tests
• Decoupled: Controller doesn't care if service uses EF or Dapper
• No memory leaks: Container calls Dispose() for you

1. Service Lifetimes Explained

DI container tracks object lifetime. Wrong lifetime = bugs.

2. Captive Dependency: The #1 DI Bug

Injecting a shorter-lived service into a longer-lived one.

// BAD: Singleton holds Scoped DbContext
builder.Services.AddSingleton<IProductService, ProductService>(); // Singleton
builder.Services.AddDbContext<AppDbContext>(); // Scoped by default

public class ProductService : IProductService
{
    public ProductService(AppDbContext db) // Captive! DbContext disposed after first request
    {
        _db = db;
    }
}

Result: Second request crashes: "Cannot access disposed DbContext".

Fix: Make ProductService Scoped, or use IServiceScopeFactory to create scope manually.

3. Multiple Implementations

Register multiple services for same interface:

builder.Services.AddScoped<INotificationService, EmailService>();
builder.Services.AddScoped<INotificationService, SmsService>();

// Inject all of them
public class OrderController : Controller
{
    public OrderController(IEnumerable<INotificationService> notifiers)
    {
        _notifiers = notifiers; // Gets both Email + SMS
    }
}

4. Factory Pattern with DI

Need to create objects at runtime? Inject a factory:

builder.Services.AddScoped<Func<string, IPaymentGateway>>(provider => key =>
{
    return key switch
    {
        "stripe" => provider.GetService<StripeGateway>(),
        "paypal" => provider.GetService<PayPalGateway>(),
        _ => throw new ArgumentException("Invalid gateway")
    };
});

// Usage
public class CheckoutController
{
    public CheckoutController(Func<string, IPaymentGateway> gatewayFactory)
    {
        _gateway = gatewayFactory("stripe");
    }
}

5. TryAdd Methods: Safe Registration

Libraries use TryAdd so they don't override your registration:

builder.Services.TryAddScoped<IProductService, ProductService>();
// Only adds if IProductService not already registered

builder.Services.TryAddEnumerable(
    ServiceDescriptor.Scoped<INotificationService, EmailService>());
// Adds to collection instead of replacing

6. Disposal & IDisposable

Container calls Dispose() automatically at end of scope:

public class FileService : IDisposable
{
    private readonly FileStream _stream;
    public FileService() => _stream = File.OpenRead("data.txt");
    public void Dispose() => _stream?.Dispose(); // Called by DI container
}

builder.Services.AddScoped<FileService>(); // Auto-disposed after request