Dependency Injection

// Registrationbuilder.Services.AddKeyedScoped<INotificationService, EmailNotificationService>("email");builder.Services.AddKeyedScoped<INotificationService, SmsNotificationService>("sms");builder.Services.AddKeyedScoped<INotificationService, PushNotificationService>("push");
// Resolution via attributepublic class OrderHandler([FromKeyedServices("email")] INotificationService notifier){    public async Task Handle(CreateOrder.Command command, CancellationToken ct)    {        // ... create order        await notifier.SendAsync(notification, ct);    }}
// Resolution via IServiceProviderpublic class NotificationRouter(IServiceProvider provider){    public INotificationService GetService(string channel)    {        return provider.GetRequiredKeyedService<INotificationService>(channel);    }}

// Base servicepublic interface IOrderService{    Task<Result<Order>> CreateAsync(CreateOrderRequest request, CancellationToken ct);}
public class OrderService(AppDbContext db, TimeProvider clock) : IOrderService{    public async Task<Result<Order>> CreateAsync(CreateOrderRequest request, CancellationToken ct)    {        var order = Order.Create(request, clock.GetUtcNow());        db.Orders.Add(order);        await db.SaveChangesAsync(ct);        return Result.Success(order);    }}
// Decorator — adds loggingpublic class LoggingOrderService(IOrderService inner, ILogger<LoggingOrderService> logger) : IOrderService{    public async Task<Result<Order>> CreateAsync(CreateOrderRequest request, CancellationToken ct)    {        logger.LogInformation("Creating order for customer {CustomerId}", request.CustomerId);        var result = await inner.CreateAsync(request, ct);        if (result.IsSuccess)            logger.LogInformation("Order {OrderId} created", result.Value.Id);        return result;    }}
// Registration with Scrutorbuilder.Services.AddScoped<IOrderService, OrderService>();builder.Services.Decorate<IOrderService, LoggingOrderService>();

// Auto-register all services matching a conventionbuilder.Services.Scan(scan => scan    .FromAssemblyOf<Program>()    .AddClasses(classes => classes.AssignableTo<ITransientService>())    .AsImplementedInterfaces()    .WithTransientLifetime()    .AddClasses(classes => classes.AssignableTo<IScopedService>())    .AsImplementedInterfaces()    .WithScopedLifetime());

builder.Services.AddScoped<IPaymentProcessor>(sp =>{    var config = sp.GetRequiredService<IOptions<PaymentOptions>>().Value;    return config.Provider switch    {        "stripe" => ActivatorUtilities.CreateInstance<StripeProcessor>(sp),        "paypal" => ActivatorUtilities.CreateInstance<PayPalProcessor>(sp),        _ => throw new InvalidOperationException($"Unknown payment provider: {config.Provider}")    };});

// Bind configuration section to a strongly-typed options classbuilder.Services.AddOptions<JwtOptions>()    .BindConfiguration("Jwt")    .ValidateDataAnnotations()    .ValidateOnStart();
// Inject as IOptions<T>public class TokenService(IOptions<JwtOptions> options){    private readonly JwtOptions _jwt = options.Value;}

// BAD — DbContext is scoped, captured by singleton = memory leak + stale databuilder.Services.AddSingleton<OrderCache>(); // depends on AppDbContext
// GOOD — use IServiceScopeFactory in singletonpublic class OrderCache(IServiceScopeFactory scopeFactory){    public async Task<Order?> GetAsync(Guid id)    {        await using var scope = scopeFactory.CreateAsyncScope();        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();        return await db.Orders.FindAsync(id);    }}

// BAD — making a service singleton when it holds mutable statebuilder.Services.AddSingleton<OrderService>(); // has DbContext dependency
// GOOD — match the lifetime to the service's needsbuilder.Services.AddScoped<OrderService>();