Dependency Injection in ASP.NET Core — How, Why and When to Use It

// ─────────────────────────────────────────────────────────────
// BAD: Tight coupling — OrderService builds its own dependency
// ─────────────────────────────────────────────────────────────
public class SmtpEmailSender
{
    public void Send(string recipient, string subject, string body)
    {
        // Imagine a real SMTP call here
        Console.WriteLine($"[SMTP] Sending '{subject}' to {recipient}");
    }
}

public class TightlyCoupledOrderService
{
    // Hard-coded dependency: we own the SmtpEmailSender, full stop.
    // To test this class without sending real emails? Impossible.
    private readonly SmtpEmailSender _emailSender = new SmtpEmailSender();

    public void PlaceOrder(string customerEmail, string productName)
    {
        Console.WriteLine($"Order placed for: {productName}");
        _emailSender.Send(customerEmail, "Order Confirmed", $"Thanks for ordering {productName}!");
    }
}

// ─────────────────────────────────────────────────────────────
// GOOD: Loose coupling via interface + constructor injection
// ─────────────────────────────────────────────────────────────

// The contract — defines WHAT, not HOW
public interface IEmailSender
{
    void Send(string recipient, string subject, string body);
}

// Real implementation for production
public class SmtpEmailSenderV2 : IEmailSender
{
    public void Send(string recipient, string subject, string body)
    {
        Console.WriteLine($"[SMTP] Sending '{subject}' to {recipient}");
    }
}

// Fake implementation for unit tests — zero side effects
public class FakeEmailSender : IEmailSender
{
    public void Send(string recipient, string subject, string body)
    {
        Console.WriteLine($"[FAKE] Would have sent '{subject}' to {recipient}");
    }
}

// OrderService now depends on the ABSTRACTION, not the concrete class.
// The DI container (or a test) will decide what IEmailSender looks like.
public class OrderService
{
    private readonly IEmailSender _emailSender;

    // Constructor injection: the dependency is DECLARED, not created
    public OrderService(IEmailSender emailSender)
    {
        _emailSender = emailSender;
    }

    public void PlaceOrder(string customerEmail, string productName)
    {
        Console.WriteLine($"Order placed for: {productName}");
        // This line is identical whether _emailSender is SMTP, SendGrid or Fake
        _emailSender.Send(customerEmail, "Order Confirmed", $"Thanks for ordering {productName}!");
    }
}

// ─────────────────────────────────────────────────────────────
// Demo — wiring it up manually to illustrate the concept
// ─────────────────────────────────────────────────────────────
class Program
{
    static void Main()
    {
        // In production: pass the real sender
        var productionService = new OrderService(new SmtpEmailSenderV2());
        productionService.PlaceOrder("alice@example.com", "Mechanical Keyboard");

        Console.WriteLine();

        // In a unit test: pass the fake — no SMTP server needed
        var testService = new OrderService(new FakeEmailSender());
        testService.PlaceOrder("bob@example.com", "USB-C Hub");
    }
}

// Program.cs — the entry point for a modern ASP.NET Core app
// This is where you tell the DI container how to build your services.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// ─── Register your services with the DI container ───────────────

// TRANSIENT: new instance every time IProductValidator is requested.
// Good for stateless operations — no shared state to worry about.
builder.Services.AddTransient<IProductValidator, ProductValidator>();

// SCOPED: one instance per HTTP request.
// All classes within a single request share the SAME OrderService instance.
// This is the correct lifetime for DbContext and most business services.
builder.Services.AddScoped<IOrderService, OrderService>();

// SINGLETON: one instance for the whole app lifetime.
// Every request, every thread gets the same PricingCache object.
// Only use this when the class is thread-safe and expensive to create.
builder.Services.AddSingleton<IPricingCache, InMemoryPricingCache>();

// Built-in registrations — AddControllers registers MVC services,
// which themselves have many internal DI registrations under the hood.
builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();
app.MapControllers();
app.Run();

// ─── Service interfaces and implementations ──────────────────────

public interface IProductValidator
{
    bool IsValid(string productName, decimal price);
}

public class ProductValidator : IProductValidator
{
    public bool IsValid(string productName, decimal price)
        => !string.IsNullOrWhiteSpace(productName) && price > 0;
}

public interface IOrderService
{
    string CreateOrder(string customerEmail, string productName, decimal price);
}

public class OrderService : IOrderService
{
    private readonly IProductValidator _validator;
    private readonly IPricingCache _pricingCache;

    // The container resolves IProductValidator and IPricingCache automatically.
    // You never call 'new OrderService(...)' yourself in production code.
    public OrderService(IProductValidator validator, IPricingCache pricingCache)
    {
        _validator = validator;
        _pricingCache = pricingCache;
    }

    public string CreateOrder(string customerEmail, string productName, decimal price)
    {
        if (!_validator.IsValid(productName, price))
            return "Order rejected: invalid product data.";

        // Use the cached price if available, otherwise use provided price
        var finalPrice = _pricingCache.GetPrice(productName) ?? price;
        return $"Order created for {customerEmail}: {productName} at ${finalPrice:F2}";
    }
}

public interface IPricingCache
{
    decimal? GetPrice(string productName);
}

public class InMemoryPricingCache : IPricingCache
{
    // Singleton means this dictionary is shared across all requests.
    // Thread safety matters here — in real code consider ConcurrentDictionary.
    private readonly Dictionary<string, decimal> _prices = new()
    {
        { "Mechanical Keyboard", 129.99m },
        { "USB-C Hub", 49.99m }
    };

    public decimal? GetPrice(string productName)
        => _prices.TryGetValue(productName, out var price) ? price : null;
}

// ─── Controller that uses OrderService via DI ────────────────────
[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly IOrderService _orderService;

    // ASP.NET Core sees this constructor and asks the DI container
    // to supply an IOrderService. It creates one (Scoped), injects it here,
    // and disposes it at the end of this HTTP request.
    public OrdersController(IOrderService orderService)
    {
        _orderService = orderService;
    }

    [HttpPost]
    public IActionResult PlaceOrder([FromBody] PlaceOrderRequest request)
    {
        var result = _orderService.CreateOrder(
            request.CustomerEmail,
            request.ProductName,
            request.Price
        );
        return Ok(new { message = result });
    }
}

public record PlaceOrderRequest(string CustomerEmail, string ProductName, decimal Price);

// A self-contained console app that mimics what ASP.NET Core DI does internally.
// Run this to SEE the lifetime differences with your own eyes.

using Microsoft.Extensions.DependencyInjection;

// ─── Service Definitions ─────────────────────────────────────────

public interface ITransientCounter { string InstanceId { get; } }
public interface IScopedCounter   { string InstanceId { get; } }
public interface ISingletonCounter { string InstanceId { get; } }

// Each service generates a unique short ID when constructed.
// If two injections share an ID, they're the same instance.
public class TransientCounter : ITransientCounter
{
    public string InstanceId { get; } = Guid.NewGuid().ToString()[..8];
    public TransientCounter() => Console.WriteLine($"  [Transient CREATED] id={InstanceId}");
}

public class ScopedCounter : IScopedCounter
{
    public string InstanceId { get; } = Guid.NewGuid().ToString()[..8];
    public ScopedCounter() => Console.WriteLine($"  [Scoped CREATED]   id={InstanceId}");
}

public class SingletonCounter : ISingletonCounter
{
    public string InstanceId { get; } = Guid.NewGuid().ToString()[..8];
    public SingletonCounter() => Console.WriteLine($"  [Singleton CREATED] id={InstanceId}");
}

// ─── A service that depends on all three ─────────────────────────
public class ReportService
{
    private readonly ITransientCounter _transient;
    private readonly IScopedCounter    _scoped;
    private readonly ISingletonCounter _singleton;

    public ReportService(
        ITransientCounter transient,
        IScopedCounter scoped,
        ISingletonCounter singleton)
    {
        _transient = transient;
        _scoped    = scoped;
        _singleton = singleton;
    }

    public void PrintIds(string label)
    {
        Console.WriteLine($"  {label}:");
        Console.WriteLine($"    Transient  id = {_transient.InstanceId}");
        Console.WriteLine($"    Scoped     id = {_scoped.InstanceId}");
        Console.WriteLine($"    Singleton  id = {_singleton.InstanceId}");
    }
}

// ─── Wiring & Demo ───────────────────────────────────────────────
var services = new ServiceCollection();
services.AddTransient<ITransientCounter, TransientCounter>();
services.AddScoped<IScopedCounter,       ScopedCounter>();
services.AddSingleton<ISingletonCounter, SingletonCounter>();
services.AddTransient<ReportService>(); // ReportService itself is Transient for this demo

var rootProvider = services.BuildServiceProvider();

Console.WriteLine("=== SIMULATED REQUEST 1 ===");
using (var scope1 = rootProvider.CreateScope())
{
    // Resolve ReportService TWICE within the same scope (same simulated request)
    var reportA = scope1.ServiceProvider.GetRequiredService<ReportService>();
    var reportB = scope1.ServiceProvider.GetRequiredService<ReportService>();

    reportA.PrintIds("ReportA (first resolve in request 1)");
    reportB.PrintIds("ReportB (second resolve in request 1)");

    Console.WriteLine();
    Console.WriteLine("  SAME Scoped instance in request 1?   " +
        (reportA.GetType().GetField("_scoped",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
            ?.GetValue(reportA) is IScopedCounter s1 &&
         reportB.GetType().GetField("_scoped",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
            ?.GetValue(reportB) is IScopedCounter s2 &&
         s1.InstanceId == s2.InstanceId ? "YES ✓" : "NO ✗"));
}

Console.WriteLine();
Console.WriteLine("=== SIMULATED REQUEST 2 ===");
using (var scope2 = rootProvider.CreateScope())
{
    var reportC = scope2.ServiceProvider.GetRequiredService<ReportService>();
    reportC.PrintIds("ReportC (first resolve in request 2)");
}

// Demonstrates three advanced DI patterns you'll encounter in real projects.
// Designed for .NET 8+ for the Keyed Services feature.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

// ─── Pattern 1: Keyed Services (.NET 8+) ─────────────────────────

public interface IPaymentProcessor
{
    string ProcessPayment(decimal amount);
}

public class StripePaymentProcessor : IPaymentProcessor
{
    public string ProcessPayment(decimal amount)
        => $"[Stripe] Charged ${amount:F2} via Stripe API";
}

public class PayPalPaymentProcessor : IPaymentProcessor
{
    public string ProcessPayment(decimal amount)
        => $"[PayPal] Charged ${amount:F2} via PayPal API";
}

// ─── Pattern 2: Factory Function Registration ─────────────────────

public class DatabaseConnectionService
{
    public string ConnectionString { get; }

    // This service needs a connection string that comes from config at runtime
    public DatabaseConnectionService(string connectionString)
    {
        ConnectionString = connectionString;
        Console.WriteLine($"  [DbConnection] Created with: {connectionString}");
    }
}

// ─── Pattern 3: IServiceScopeFactory in a Singleton ───────────────

public class OrderCleanupBackgroundService : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;

    // We inject IServiceScopeFactory (which IS a Singleton) — safe!
    // We do NOT inject IOrderRepository (which is Scoped) directly — that would be a bug.
    public OrderCleanupBackgroundService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            Console.WriteLine("\n[BackgroundService] Starting cleanup cycle...");

            // Create a scope manually — this mimics what ASP.NET Core
            // does automatically for each HTTP request.
            using (var scope = _scopeFactory.CreateScope())
            {
                // Now safely resolve the Scoped service within our controlled scope
                var repository = scope.ServiceProvider
                    .GetRequiredService<IOrderRepository>();

                await repository.DeleteExpiredOrdersAsync();

                // When 'using' block exits, scope is disposed,
                // and so is the Scoped IOrderRepository instance.
            }

            await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
        }
    }
}

public interface IOrderRepository
{
    Task DeleteExpiredOrdersAsync();
}

public class SqlOrderRepository : IOrderRepository
{
    public async Task DeleteExpiredOrdersAsync()
    {
        await Task.Delay(50); // Simulates a DB call
        Console.WriteLine("  [SqlOrderRepository] Deleted expired orders from database.");
    }
}

// ─── Wiring everything up ─────────────────────────────────────────
var builder = Host.CreateApplicationBuilder(args);

// Keyed registrations — same interface, two keys
builder.Services.AddKeyedScoped<IPaymentProcessor, StripePaymentProcessor>("stripe");
builder.Services.AddKeyedScoped<IPaymentProcessor, PayPalPaymentProcessor>("paypal");

// Factory function — lambda provides the runtime connection string
builder.Services.AddScoped<DatabaseConnectionService>(serviceProvider =>
{
    // In real code, you'd pull this from IConfiguration:
    // var config = serviceProvider.GetRequiredService<IConfiguration>();
    // var connStr = config.GetConnectionString("Default");
    var connStr = "Server=prod-db;Database=orders;Trusted_Connection=true";
    return new DatabaseConnectionService(connStr);
});

// Scoped repository + Singleton background service using scope factory
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddHostedService<OrderCleanupBackgroundService>();

var host = builder.Build();

// ─── Demo: Resolving keyed services ──────────────────────────────
using var demoScope = host.Services.CreateScope();
var sp = demoScope.ServiceProvider;

// [FromKeyedServices("stripe")] attribute does this automatically in controllers
var stripeProcessor = sp.GetRequiredKeyedService<IPaymentProcessor>("stripe");
var paypalProcessor = sp.GetRequiredKeyedService<IPaymentProcessor>("paypal");

Console.WriteLine(stripeProcessor.ProcessPayment(99.99m));
Console.WriteLine(paypalProcessor.ProcessPayment(49.50m));

var dbService = sp.GetRequiredService<DatabaseConnectionService>();
Console.WriteLine($"  Connection string in use: {dbService.ConnectionString}");

// Run the host briefly to see background service fire
await host.StartAsync();
await Task.Delay(2000);
await host.StopAsync();