🏗️ Advanced DI = Clean Architecture
Basic DI is just the beginning. Advanced DI patterns enable clean architecture and enterprise-grade applications.
📝 Advanced DI Patterns
// Decorator Pattern
public interface IOrderService
{
Task CreateOrderAsync(OrderDto dto);
}
public class LoggingOrderServiceDecorator : IOrderService
{
private readonly IOrderService _inner;
private readonly ILogger _logger;
public LoggingOrderServiceDecorator(IOrderService inner, ILogger logger)
{
_inner = inner;
_logger = logger;
}
public async Task CreateOrderAsync(OrderDto dto)
{
_logger.LogInformation("Creating order...");
var result = await _inner.CreateOrderAsync(dto);
_logger.LogInformation("Order created: {OrderId}", result.Id);
return result;
}
}
// Chain of Responsibility
public interface IHandler
{
IHandler SetNext(IHandler handler);
Task HandleAsync(T request);
}
// Strategy Pattern with DI
public interface IPaymentStrategy
{
Task ProcessAsync(PaymentRequest request);
}
public class PaymentService
{
private readonly IEnumerable _strategies;
public PaymentService(IEnumerable strategies)
{
_strategies = strategies;
}
public async Task ProcessPaymentAsync(PaymentRequest request)
{
var strategy = _strategies.FirstOrDefault(s => s.CanProcess(request));
if (strategy == null)
throw new NotSupportedException();
return await strategy.ProcessAsync(request);
}
}
🎯 Registration Patterns
// Convention-Based Registration
public static class ServiceCollectionExtensions
{
public static IServiceCollection AddServices(this IServiceCollection services)
{
// Register all services by convention
services.Scan(scan => scan
.FromAssembliesOf()
.AddClasses(classes => classes.AssignableTo())
.AsImplementedInterfaces()
.WithScopedLifetime()
);
return services;
}
}
// Keyed Services (.NET 8)
builder.Services.AddKeyedScoped("credit");
builder.Services.AddKeyedScoped("paypal");
builder.Services.AddKeyedScoped("bank");
[FromKeyedServices("credit")] private readonly IPaymentStrategy _strategy;
// Factory Pattern
public interface IServiceFactory
{
T Create(string key);
}
public class ServiceFactory : IServiceFactory
{
private readonly IServiceProvider _provider;
private readonly Dictionary _mappings;
public ServiceFactory(IServiceProvider provider, Dictionary mappings)
{
_provider = provider;
_mappings = mappings;
}
public T Create(string key)
{
if (!_mappings.TryGetValue(key, out var type))
throw new ArgumentException($"Invalid key: {key}");
return (T)_provider.GetRequiredService(type);
}
}
💡 Advanced DI Tips
- Use decorators for cross-cutting concerns
- Implement strategy pattern for variations
- Use factory pattern for complex creation
- Register services by convention
- Use keyed services for multiple implementations
Advanced DI patterns enable clean, maintainable, and testable enterprise applications.

