IoC Container Deep Dive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// Assembly scanning with Scrutor (popular .NET library)
// Demonstrates various scanning and registration patterns
 
public static class ServiceRegistration
{
    public static IServiceCollection AddApplicationServices(
        this IServiceCollection services)
    {
        // PATTERN 1: Scan assembly containing a marker type
        services.Scan(scan => scan
            .FromAssemblyOf<UserService>()  // Scan assembly containing UserService
            
            // Include only classes
            .AddClasses(classes => classes
                .Where(type => type.Name.EndsWith("Service")))  // Name convention
            
            // Register as their implemented interfaces
            .AsImplementedInterfaces()
            
            // With scoped lifetime
            .WithScopedLifetime()
        );
        
        // PATTERN 2: Multiple assemblies with different conventions
        services.Scan(scan => scan
            // Scan multiple assemblies
            .FromAssemblies(
                typeof(UserRepository).Assembly,      // Data layer
                typeof(UserService).Assembly,         // Application layer
                typeof(EmailNotificationSender).Assembly  // Infrastructure
            )
            
            // Repositories - transient
            .AddClasses(classes => classes
                .Where(type => type.Name.EndsWith("Repository")))
            .AsImplementedInterfaces()
            .WithScopedLifetime()
            
            // Handlers - transient
            .AddClasses(classes => classes
                .AssignableTo(typeof(IEventHandler<>)))  // Marker interface
            .AsImplementedInterfaces()
            .WithTransientLifetime()
            
            // Validators - transient
            .AddClasses(classes => classes
                .AssignableTo(typeof(IValidator<>)))
            .AsImplementedInterfaces()
            .WithTransientLifetime()
        );
        
        // PATTERN 3: Attribute-based filtering
        services.Scan(scan => scan
            .FromAssemblyOf<ApplicationMarker>()
            
            // Only classes with [Service] attribute
            .AddClasses(classes => classes
                .WithAttribute<ServiceAttribute>())
            .AsImplementedInterfaces()
            .WithLifetimeFromAttribute()  // Lifetime specified in attribute
        );
        
        // PATTERN 4: Namespace-based conventions
        services.Scan(scan => scan
            .FromAssemblyOf<ApplicationMarker>()
            
            // Services namespace -> Scoped
            .AddClasses(classes => classes
                .InNamespaceOf<UserService>())  // MyApp.Services namespace
            .AsImplementedInterfaces()
            .WithScopedLifetime()
            
            // Repositories namespace -> Scoped  
            .AddClasses(classes => classes
                .InNamespaces("MyApp.Data.Repositories"))
            .AsImplementedInterfaces()
            .WithScopedLifetime()
            
            // Singletons namespace -> Singleton
            .AddClasses(classes => classes
                .InNamespaces("MyApp.Infrastructure.Singletons"))
            .AsImplementedInterfaces()
            .WithSingletonLifetime()
        );
        
        return services;
    }
}
 
// Custom attribute for fine-grained control
[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
    public ServiceLifetime Lifetime { get; }
    
    public ServiceAttribute(ServiceLifetime lifetime = ServiceLifetime.Scoped)
    {
        Lifetime = lifetime;
    }
}
 
// Usage
[Service(ServiceLifetime.Singleton)]
public class ConfigurationService : IConfigurationService
{
    // Implementation
}
 
[Service(ServiceLifetime.Scoped)]
public class OrderProcessingService : IOrderProcessingService
{
    // Implementation
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

// Comprehensive convention pattern implementation
// Shows multiple strategies working together
 
// PATTERN 1: Marker Interfaces for Lifetime
// Clean, explicit, no magic strings
 
public interface ITransientService { }
public interface IScopedService { }
public interface ISingletonService { }
 
// Usage - lifetime is obvious from interface
public class EmailValidator : IEmailValidator, ITransientService
{
    public bool Validate(string email) => email.Contains("@");
}
 
public class UserContextProvider : IUserContextProvider, IScopedService
{
    public UserContext Current { get; private set; }
}
 
public class ApplicationConfiguration : IApplicationConfiguration, ISingletonService
{
    public string Environment { get; }
    public string Version { get; }
}
 
// Registration
services.Scan(scan => scan
    .FromAssemblyOf<ApplicationMarker>()
    
    .AddClasses(c => c.AssignableTo<ITransientService>())
    .AsImplementedInterfaces()
    .WithTransientLifetime()
    
    .AddClasses(c => c.AssignableTo<IScopedService>())
    .AsImplementedInterfaces()
    .WithScopedLifetime()
    
    .AddClasses(c => c.AssignableTo<ISingletonService>())
    .AsImplementedInterfaces()
    .WithSingletonLifetime()
);
 
 
// PATTERN 2: Generic Handler Registration
// Register all implementations of open generic interfaces
 
public interface ICommandHandler<TCommand, TResult>
{
    Task<TResult> HandleAsync(TCommand command, CancellationToken ct);
}
 
public interface IEventHandler<TEvent>
{
    Task HandleAsync(TEvent @event, CancellationToken ct);
}
 
public interface IQueryHandler<TQuery, TResult>
{
    Task<TResult> HandleAsync(TQuery query, CancellationToken ct);
}
 
// Implementations
public class CreateUserCommandHandler 
    : ICommandHandler<CreateUserCommand, UserDto>
{
    public async Task<UserDto> HandleAsync(
        CreateUserCommand command, 
        CancellationToken ct)
    {
        // Implementation
        return new UserDto();
    }
}
 
public class UserCreatedEventHandler : IEventHandler<UserCreatedEvent>
{
    public async Task HandleAsync(UserCreatedEvent @event, CancellationToken ct)
    {
        // Send welcome email, etc.
    }
}
 
// Registration - single scan registers ALL handlers
services.Scan(scan => scan
    .FromAssemblyOf<CreateUserCommandHandler>()
    
    // Command handlers
    .AddClasses(c => c.AssignableTo(typeof(ICommandHandler<,>)))
    .AsImplementedInterfaces()
    .WithScopedLifetime()
    
    // Event handlers
    .AddClasses(c => c.AssignableTo(typeof(IEventHandler<>)))
    .AsImplementedInterfaces()
    .WithTransientLifetime()
    
    // Query handlers
    .AddClasses(c => c.AssignableTo(typeof(IQueryHandler<,>)))
    .AsImplementedInterfaces()
    .WithScopedLifetime()
);
 
 
// PATTERN 3: Convention with Explicit Overrides
// Scan with conventions, then override specific registrations
 
public static IServiceCollection AddDomainServices(
    this IServiceCollection services,
    IConfiguration configuration)
{
    // Step 1: Bulk registration via conventions
    services.Scan(scan => scan
        .FromAssemblyOf<DomainMarker>()
        
        .AddClasses(c => c.Where(t => t.Name.EndsWith("Service")))
        .AsImplementedInterfaces()
        .WithScopedLifetime()
    );
    
    // Step 2: Explicit overrides for special cases
    // These replace the convention-registered versions
    
    // PaymentService needs special factory with configuration
    services.AddScoped<IPaymentService>(sp =>
    {
        var gateway = configuration["Payment:Gateway"];
        var apiKey = configuration["Payment:ApiKey"];
        return gateway switch
        {
            "stripe" => new StripePaymentService(apiKey),
            "paypal" => new PayPalPaymentService(apiKey),
            _ => throw new InvalidOperationException($"Unknown gateway: {gateway}")
        };
    });
    
    // CacheService needs singleton, not scoped
    services.AddSingleton<ICacheService, RedisCacheService>();
    
    // LoggingService needs decorator chain
    services.AddScoped<ILoggingService>(sp =>
    {
        var baseLogger = new ConsoleLoggingService();
        var metricsLogger = new MetricsLoggingDecorator(baseLogger, sp.GetRequiredService<IMetrics>());
        return new AsyncLoggingDecorator(metricsLogger);
    });
    
    return services;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// Advanced batch registration strategies
 
// STRATEGY 1: Decorator Chain Registration
// Automatically wrap services with cross-cutting concerns
 
public static class DecoratorRegistration
{
    public static IServiceCollection AddDecoratedServices(
        this IServiceCollection services)
    {
        // Step 1: Register base implementations
        services.Scan(scan => scan
            .FromAssemblyOf<UserRepository>()
            .AddClasses(c => c.Where(t => t.Name.EndsWith("Repository")))
            .AsImplementedInterfaces()
            .WithScopedLifetime()
        );
        
        // Step 2: Wrap all IRepository<T> with decorators
        services.Decorate(typeof(IRepository<>), typeof(LoggingRepositoryDecorator<>));
        services.Decorate(typeof(IRepository<>), typeof(CachingRepositoryDecorator<>));
        services.Decorate(typeof(IRepository<>), typeof(MetricsRepositoryDecorator<>));
        
        // Result: Metrics -> Caching -> Logging -> Base
        // Every repository gets all three decorators automatically
        
        return services;
    }
}
 
// STRATEGY 2: Module-Based Batch Registration
// Each feature module registers its own services
 
public interface IServiceModule
{
    void Register(IServiceCollection services, IConfiguration configuration);
}
 
public class UserModule : IServiceModule
{
    public void Register(IServiceCollection services, IConfiguration configuration)
    {
        services.Scan(scan => scan
            .FromAssemblyOf<UserModule>()
            .AddClasses(c => c.InNamespaceOf<UserService>())
            .AsImplementedInterfaces()
            .WithScopedLifetime()
        );
    }
}
 
public class OrderModule : IServiceModule
{
    public void Register(IServiceCollection services, IConfiguration configuration)
    {
        services.Scan(scan => scan
            .FromAssemblyOf<OrderModule>()
            .AddClasses(c => c.InNamespaceOf<OrderService>())
            .AsImplementedInterfaces()
            .WithScopedLifetime()
        );
        
        // Module-specific singleton
        services.AddSingleton<IOrderNumberGenerator, SequentialOrderNumberGenerator>();
    }
}
 
// Auto-discover and apply all modules
public static class ModuleRegistration
{
    public static IServiceCollection AddAllModules(
        this IServiceCollection services,
        IConfiguration configuration,
        params Assembly[] assemblies)
    {
        var moduleTypes = assemblies
            .SelectMany(a => a.GetTypes())
            .Where(t => typeof(IServiceModule).IsAssignableFrom(t))
            .Where(t => t.IsClass && !t.IsAbstract);
        
        foreach (var moduleType in moduleTypes)
        {
            var module = (IServiceModule)Activator.CreateInstance(moduleType)!;
            module.Register(services, configuration);
        }
        
        return services;
    }
}
 
// Usage
services.AddAllModules(
    configuration,
    typeof(UserModule).Assembly,
    typeof(OrderModule).Assembly,
    typeof(PaymentModule).Assembly
);
 
 
// STRATEGY 3: Profile-Based Registration
// Different registrations for different environments
 
public interface IRegistrationProfile
{
    bool IsActive(IWebHostEnvironment environment);
    void Register(IServiceCollection services);
}
 
public class DevelopmentProfile : IRegistrationProfile
{
    public bool IsActive(IWebHostEnvironment env) => env.IsDevelopment();
    
    public void Register(IServiceCollection services)
    {
        // Development-specific registrations
        services.AddSingleton<IEmailSender, FakeEmailSender>();
        services.AddSingleton<IPaymentGateway, MockPaymentGateway>();
        services.AddSingleton<ILogger, ColoredConsoleLogger>();
    }
}
 
public class ProductionProfile : IRegistrationProfile
{
    public bool IsActive(IWebHostEnvironment env) => env.IsProduction();
    
    public void Register(IServiceCollection services)
    {
        // Production-specific registrations
        services.AddSingleton<IEmailSender, SendGridEmailSender>();
        services.AddSingleton<IPaymentGateway, StripePaymentGateway>();
        services.AddSingleton<ILogger, CloudWatchLogger>();
    }
}
 
public static class ProfileRegistration
{
    public static IServiceCollection AddProfiles(
        this IServiceCollection services,
        IWebHostEnvironment environment)
    {
        var profiles = typeof(ProfileRegistration).Assembly
            .GetTypes()
            .Where(t => typeof(IRegistrationProfile).IsAssignableFrom(t))
            .Where(t => t.IsClass && !t.IsAbstract)
            .Select(t => (IRegistrationProfile)Activator.CreateInstance(t)!)
            .Where(p => p.IsActive(environment));
        
        foreach (var profile in profiles)
        {
            profile.Register(services);
        }
        
        return services;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

// Comprehensive registration validation and diagnostics
 
public static class ContainerValidation
{
    // Validate all expected services are registered
    public static void ValidateRegistrations(
        this IServiceProvider serviceProvider,
        params Type[] expectedServices)
    {
        var missing = new List<Type>();
        var errors = new List<(Type, Exception)>();
        
        foreach (var serviceType in expectedServices)
        {
            try
            {
                var service = serviceProvider.GetService(serviceType);
                if (service == null)
                {
                    missing.Add(serviceType);
                }
            }
            catch (Exception ex)
            {
                errors.Add((serviceType, ex));
            }
        }
        
        if (missing.Any() || errors.Any())
        {
            var sb = new StringBuilder();
            sb.AppendLine("Container validation failed:");
            
            if (missing.Any())
            {
                sb.AppendLine("Missing registrations:");
                foreach (var type in missing)
                {
                    sb.AppendLine($"  - {type.FullName}");
                }
            }
            
            if (errors.Any())
            {
                sb.AppendLine("Resolution errors:");
                foreach (var (type, ex) in errors)
                {
                    sb.AppendLine($"  - {type.FullName}: {ex.Message}");
                }
            }
            
            throw new InvalidOperationException(sb.ToString());
        }
    }
    
    // Validate all interfaces have implementations
    public static void ValidateNoMissingImplementations(
        this IServiceCollection services,
        params Assembly[] assemblies)
    {
        // Find all interfaces marked as services
        var serviceInterfaces = assemblies
            .SelectMany(a => a.GetTypes())
            .Where(t => t.IsInterface)
            .Where(t => t.Name.StartsWith("I"))
            .Where(t => t.Name.EndsWith("Service") 
                     || t.Name.EndsWith("Repository")
                     || t.Name.EndsWith("Handler"))
            .ToList();
        
        var registeredServices = services
            .Select(sd => sd.ServiceType)
            .ToHashSet();
        
        var unregistered = serviceInterfaces
            .Where(i => !registeredServices.Contains(i))
            .ToList();
        
        if (unregistered.Any())
        {
            var message = "Unregistered service interfaces:\n" +
                string.Join("\n", unregistered.Select(t => $"  - {t.FullName}"));
            throw new InvalidOperationException(message);
        }
    }
}
 
// Diagnostic output for debugging registration issues
public static class RegistrationDiagnostics
{
    public static void PrintRegistrations(
        this IServiceCollection services,
        ILogger logger)
    {
        var grouped = services
            .GroupBy(sd => sd.Lifetime)
            .OrderBy(g => g.Key);
        
        foreach (var group in grouped)
        {
            logger.LogInformation("=== {Lifetime} Services ===", group.Key);
            
            foreach (var descriptor in group.OrderBy(d => d.ServiceType.Name))
            {
                var implName = descriptor.ImplementationType?.Name 
                    ?? descriptor.ImplementationFactory?.Method.Name 
                    ?? "Instance";
                
                logger.LogInformation(
                    "  {ServiceType} -> {Implementation}",
                    descriptor.ServiceType.Name,
                    implName
                );
            }
        }
    }
    
    // Detect potential issues
    public static void DetectCommonIssues(
        this IServiceCollection services,
        ILogger logger)
    {
        // Issue 1: Singleton depending on Scoped
        var singletons = services
            .Where(sd => sd.Lifetime == ServiceLifetime.Singleton)
            .Select(sd => sd.ServiceType)
            .ToHashSet();
        
        var scoped = services
            .Where(sd => sd.Lifetime == ServiceLifetime.Scoped)
            .Select(sd => sd.ServiceType)
            .ToHashSet();
        
        // Would need constructor inspection for full analysis
        // This is simplified
        
        // Issue 2: Multiple registrations for same service
        var duplicates = services
            .GroupBy(sd => sd.ServiceType)
            .Where(g => g.Count() > 1)
            .Select(g => new { 
                Type = g.Key, 
                Implementations = g.Select(sd => sd.ImplementationType?.Name).ToList() 
            });
        
        foreach (var dup in duplicates)
        {
            logger.LogWarning(
                "Multiple registrations for {Type}: {Implementations}",
                dup.Type.Name,
                string.Join(", ", dup.Implementations)
            );
        }
    }
}
 
// Usage at startup
var builder = WebApplication.CreateBuilder(args);
 
// Configure services with scanning
builder.Services.AddApplicationServices();
 
// Validate before building
#if DEBUG
builder.Services.PrintRegistrations(builder.Logging.CreateLogger("DI"));
builder.Services.DetectCommonIssues(builder.Logging.CreateLogger("DI"));
#endif
 
var app = builder.Build();
 
// Validate critical services can be resolved
app.Services.ValidateRegistrations(
    typeof(IUserService),
    typeof(IOrderService),
    typeof(IPaymentService),
    typeof(ILogger)
);