Dependency Injection in .NET, explained visually

public sealed class InvoiceService
{
    private readonly IInvoiceRepository _repo;
    private readonly ILogger<InvoiceService> _log;

    public InvoiceService(IInvoiceRepository repo, ILogger<InvoiceService> log)
    {
        _repo = repo;
        _log = log;
    }
}

public sealed class InvoiceService(IInvoiceRepository repo, ILogger<InvoiceService> log)
{
    public async Task<Invoice?> GetAsync(int id)
    {
        log.LogInformation("Loading invoice {Id}", id);
        return await repo.FindAsync(id);
    }
}

// Minimal API: services are inferred from registered types (or mark with [FromServices])
app.MapPost("/orders", async (CreateOrder dto, IOrderService orders) =>
    Results.Ok(await orders.CreateAsync(dto)));

// MVC controller action injection
public IActionResult Export([FromServices] IPdfExporter exporter) => File(exporter.Render(), "application/pdf");

// Middleware: scoped services go in InvokeAsync, not the constructor
public sealed class TenantMiddleware(RequestDelegate next)
{
    public async Task InvokeAsync(HttpContext ctx, ITenantContext tenant)  // per request
    {
        tenant.Id = ctx.Request.Headers["X-Tenant"];
        await next(ctx);
    }
}

@inject NavigationManager Nav
@code {
    [Inject] public IWeatherService Weather { get; set; } = default!;
    [Inject(Key = "eu")] public IPricing Pricing { get; set; } = default!;   // keyed (.NET 8+)
}

public class ReportService(IServiceProvider sp)
{
    public void Run()
    {
        var repo = sp.GetRequiredService<IReportRepository>();  // ❌ hidden dependency
        var mail = sp.GetService<IEmailSender>();               // ❌ might be null at runtime
    }
}

public sealed class SmtpOptions
{
    [Required] public string Host { get; set; } = "";
    [Range(1, 65535)] public int Port { get; set; } = 587;
}

builder.Services.AddOptions<SmtpOptions>()
    .BindConfiguration("Smtp")
    .ValidateDataAnnotations()
    .ValidateOnStart();                               // fail at startup, not on the first email

public sealed class SmtpEmailSender(IOptions<SmtpOptions> options) : IEmailSender
{
    private readonly SmtpOptions _o = options.Value;
}

public interface IImportJobFactory { ImportJob Create(string csvPath); }

public sealed class ImportJobFactory(IServiceProvider sp) : IImportJobFactory
{
    public ImportJob Create(string csvPath) =>
        ActivatorUtilities.CreateInstance<ImportJob>(sp, csvPath);   // csvPath + injected services
}

public sealed class ImportJob(string csvPath, ICustomerRepository repo, ILogger<ImportJob> log) { }

builder.Services.AddSingleton<IImportJobFactory, ImportJobFactory>();

public sealed class CachedProductRepository(IProductRepository inner, IMemoryCache cache) : IProductRepository
{
    public Task<Product?> GetAsync(int id) =>
        cache.GetOrCreateAsync($"p:{id}", _ => inner.GetAsync(id));
}

// Manual (no packages)
builder.Services.AddScoped<SqlProductRepository>();
builder.Services.AddScoped<IProductRepository>(sp =>
    new CachedProductRepository(sp.GetRequiredService<SqlProductRepository>(),
                                sp.GetRequiredService<IMemoryCache>()));

// Scrutor 7.x
builder.Services.AddScoped<IProductRepository, SqlProductRepository>();
builder.Services.Decorate<IProductRepository, CachedProductRepository>();

public interface IDiscountRule { bool Applies(Cart c); decimal Discount(Cart c); }

builder.Services.AddScoped<IDiscountRule, DiwaliSaleRule>();
builder.Services.AddScoped<IDiscountRule, FirstOrderRule>();
builder.Services.AddScoped<IDiscountRule, LoyaltyTierRule>();

public sealed class PricingService(IEnumerable<IDiscountRule> rules)
{
    public decimal Total(Cart c) =>
        c.Subtotal - rules.Where(r => r.Applies(c)).Sum(r => r.Discount(c));
}
// Add a new rule = add a class + one line. PricingService never changes (open/closed principle).

builder.Services.AddHttpClient<IWeatherApi, WeatherApi>(c =>
{
    c.BaseAddress = new Uri("https://api.weather.example/");
    c.Timeout = TimeSpan.FromSeconds(10);
})
.AddStandardResilienceHandler();      // Microsoft.Extensions.Http.Resilience: retries, timeouts, circuit breaker

public sealed class WeatherApi(HttpClient http) : IWeatherApi
{
    public Task<Forecast?> TodayAsync(string city) =>
        http.GetFromJsonAsync<Forecast>($"forecast/{Uri.EscapeDataString(city)}");
}

public sealed class LazyService<T>(IServiceProvider sp) : Lazy<T>(sp.GetRequiredService<T>) where T : notnull;

builder.Services.AddTransient(typeof(Lazy<>), typeof(LazyService<>));

public sealed class ReportController(Lazy<IPdfRenderer> pdf)   // created only if used
{
    public IActionResult Pdf() => new FileContentResult(pdf.Value.Render(), "application/pdf");
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<FoodDbContext>(o =>
    o.UseNpgsql(builder.Configuration.GetConnectionString("Food")));         // scoped
builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddScoped<ICurrentUser, HttpCurrentUser>();                 // per request
builder.Services.AddHttpContextAccessor();
builder.Services.AddKeyedScoped<IPaymentGateway, RazorpayGateway>("razorpay");
builder.Services.AddSingleton<IEventBus, RabbitMqEventBus>();                // shared connection
builder.Services.AddHttpClient<IMapsApi, MapsApi>();                         // typed client
builder.Services.AddSingleton(TimeProvider.System);
builder.Services.AddControllers();

var app = builder.Build();                 // Development: ValidateScopes + ValidateOnBuild run here

// Run a scoped service once at startup (migrations, seeding)
await using (var scope = app.Services.CreateAsyncScope())
{
    var db = scope.ServiceProvider.GetRequiredService<FoodDbContext>();
    await db.Database.MigrateAsync();
}

app.UseMiddleware<RequestTimingMiddleware>();
app.MapControllers();
app.MapPost("/orders", async (PlaceOrder cmd, IOrderService orders, CancellationToken ct) =>
    Results.Created($"/orders/{(await orders.PlaceAsync(cmd, ct)).Id}", null));
app.Run();

<Application x:Class="PharmacyPos.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             Startup="OnStartup" Exit="OnExit">
</Application>

public partial class App : Application
{
    private IHost _host = null!;

    private async void OnStartup(object sender, StartupEventArgs e)
    {
        var builder = Host.CreateApplicationBuilder();             // config, logging, DI

        builder.Services.AddDbContextFactory<PosDbContext>(o => o.UseSqlite("Data Source=pos.db"));
        builder.Services.AddSingleton<IDialogService, DialogService>();
        builder.Services.AddSingleton<IWindowFactory, WindowFactory>();
        builder.Services.AddSingleton<MainViewModel>();
        builder.Services.AddSingleton<MainWindow>();
        builder.Services.AddTransient<SaleViewModel>();            // one per sale window
        builder.Services.AddTransient<SaleWindow>();
        builder.Services.AddScoped<ISaleSession, SaleSession>();   // shared inside one window's scope

        _host = builder.Build();
        await _host.StartAsync();
        _host.Services.GetRequiredService<MainWindow>().Show();   // composition root: OK here
    }

    private async void OnExit(object sender, ExitEventArgs e)
    {
        using (_host) { await _host.StopAsync(); }
    }
}

public partial class MainWindow : Window
{
    public MainWindow(MainViewModel vm)          // ✅ ViewModel injected, set as DataContext
    {
        InitializeComponent();
        DataContext = vm;
    }
}

public sealed class MainViewModel(IWindowFactory windows, IDbContextFactory<PosDbContext> dbs)
{
    public async Task LoadLowStockAsync()
    {
        await using var db = await dbs.CreateDbContextAsync();     // short-lived context per operation
        LowStock = await db.Medicines.Where(m => m.Qty < 10).ToListAsync();
    }
    public void NewSale() => windows.ShowSaleWindow();
    public List<Medicine> LowStock { get; private set; } = [];
}

public sealed class WindowFactory(IServiceScopeFactory scopes) : IWindowFactory
{
    public void ShowSaleWindow()
    {
        var scope = scopes.CreateScope();                           // ✅ a scope per window
        var window = scope.ServiceProvider.GetRequiredService<SaleWindow>();
        window.Closed += (_, _) => scope.Dispose();                // dispose with the window
        window.Show();
    }
}

builder.Services.AddSingleton(Channel.CreateBounded<EmailJob>(500));   // the queue is a singleton
builder.Services.AddHostedService<EmailQueueWorker>();

app.MapPost("/newsletter", (Channel<EmailJob> q, EmailJob job) => q.Writer.TryWrite(job)
    ? Results.Accepted() : Results.StatusCode(503));

public sealed class EmailQueueWorker(Channel<EmailJob> q, IServiceScopeFactory scopes) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await foreach (var job in q.Reader.ReadAllAsync(ct))
        {
            await using var scope = scopes.CreateAsyncScope();
            await scope.ServiceProvider.GetRequiredService<IEmailSender>().SendAsync(job, ct);
        }
    }
}