7a:Tca4,// Modern TypeScript DI Container Configuration // Using InversifyJS as example (concepts transfer to any container) import { Container } from 'inversify'; import { TYPES } from './types'; // Interfaces (abstractions) interface ILogger { log(message: string): void; } interface IDatabase { query(sql: string): Promise; } interface IUserRepository { findById(id: string): Promise; save(user: User): Promise; } interface IUserService { getUser(id: string): Promise; createUser(data: CreateUserDTO): Promise; } // Concrete implementations class ConsoleLogger implements ILogger { log(message: string): void { console.log(`[${new Date().toISOString()}] ${message}`); } } class PostgresDatabase implements IDatabase { constructor(private connectionString: string) {} async query(sql: string): Promise { // PostgreSQL query implementation return []; } } class UserRepository implements IUserRepository { constructor( private database: IDatabase, private logger: ILogger ) {} async findById(id: string): Promise { this.logger.log(`Finding user: ${id}`); const results = await this.database.query( `SELECT * FROM users WHERE id = $1` ); return results[0] ?? null; } async save(user: User): Promise { this.logger.log(`Saving user: ${user.id}`); await this.database.query( `INSERT INTO users (id, name, email) VALUES ($1, $2, $3)` ); } } class UserService implements IUserService { constructor( private userRepository: IUserRepository, private logger: ILogger ) {} async getUser(id: string): Promise { this.logger.log(`Getting user: ${id}`); const user = await this.userRepository.findById(id); if (!user) throw new Error(`User not found: ${id}`); return user; } async createUser(data: CreateUserDTO): Promise { this.logger.log(`Creating user: ${data.email}`); const user = new User(generateId(), data.name, data.email); await this.userRepository.save(user); return user; } } // Container configuration - THE KEY PART function configureContainer(): Container { const container = new Container(); // Register abstractions to implementations container.bind(TYPES.ILogger) .to(ConsoleLogger) .inSingletonScope(); // One instance for entire application container.bind(TYPES.IDatabase) .toDynamicValue(() => new PostgresDatabase( process.env.DATABASE_URL! )) .inSingletonScope(); container.bind(TYPES.IUserRepository) .to(UserRepository) .inTransientScope(); // New instance per resolution container.bind(TYPES.IUserService) .to(UserService) .inRequestScope(); // One instance per request return container; } // Usage in composition root const container = configureContainer(); const userService = container.get(TYPES.IUserService);7b:Tddf,// Modern C# DI Container Configuration // Using Microsoft.Extensions.DependencyInjection using Microsoft.Extensions.DependencyInjection; // Interfaces (abstractions) public interface ILogger { void Log(string message); } public interface IDatabase { Task> QueryAsync(string sql); } public interface IUserRepository { Task FindByIdAsync(string id); Task SaveAsync(User user); } public interface IUserService { Task GetUserAsync(string id); Task CreateUserAsync(CreateUserDTO data); } // Concrete implementations public class ConsoleLogger : ILogger { public void Log(string message) { Console.WriteLine($"[{DateTime.UtcNow:O}] {message}"); } } public class PostgresDatabase : IDatabase { private readonly string _connectionString; public PostgresDatabase(string connectionString) { _connectionString = connectionString; } public async Task> QueryAsync(string sql) { // PostgreSQL query implementation return Enumerable.Empty(); } } public class UserRepository : IUserRepository { private readonly IDatabase _database; private readonly ILogger _logger; public UserRepository(IDatabase database, ILogger logger) { _database = database; _logger = logger; } public async Task FindByIdAsync(string id) { _logger.Log($"Finding user: {id}"); var results = await _database.QueryAsync( $"SELECT * FROM users WHERE id = @id" ); return results.FirstOrDefault(); } public async Task SaveAsync(User user) { _logger.Log($"Saving user: {user.Id}"); await _database.QueryAsync( "INSERT INTO users (id, name, email) VALUES (@id, @name, @email)" ); } } public class UserService : IUserService { private readonly IUserRepository _userRepository; private readonly ILogger _logger; public UserService(IUserRepository userRepository, ILogger logger) { _userRepository = userRepository; _logger = logger; } public async Task GetUserAsync(string id) { _logger.Log($"Getting user: {id}"); var user = await _userRepository.FindByIdAsync(id); return user ?? throw new UserNotFoundException(id); } public async Task CreateUserAsync(CreateUserDTO data) { _logger.Log($"Creating user: {data.Email}"); var user = new User(Guid.NewGuid().ToString(), data.Name, data.Email); await _userRepository.SaveAsync(user); return user; } } // Container configuration - THE KEY PART public static class ServiceConfiguration { public static IServiceCollection ConfigureServices( this IServiceCollection services, IConfiguration configuration) { // Register with lifecycle specifications services.AddSingleton(); services.AddSingleton(sp => new PostgresDatabase( configuration.GetConnectionString("Default")! ) ); services.AddTransient(); services.AddScoped(); return services; } } // Usage in Program.cs (composition root) var builder = WebApplication.CreateBuilder(args); builder.Services.ConfigureServices(builder.Configuration); var app = builder.Build();7c:Te1a,// Modern Java DI Container Configuration // Using Spring Framework (concepts transfer to Guice, Dagger, etc.) // Interfaces (abstractions) public interface Logger { void log(String message); } public interface Database { List query(String sql, Class resultType); } public interface UserRepository { Optional findById(String id); void save(User user); } public interface UserService { User getUser(String id); User createUser(CreateUserDTO data); } // Concrete implementations @Component public class ConsoleLogger implements Logger { @Override public void log(String message) { System.out.println(String.format("[%s] %s", Instant.now(), message)); } } @Component public class PostgresDatabase implements Database { private final String connectionString; public PostgresDatabase( @Value("${database.connection-string}") String connectionString ) { this.connectionString = connectionString; } @Override public List query(String sql, Class resultType) { // PostgreSQL query implementation return List.of(); } } @Repository public class UserRepositoryImpl implements UserRepository { private final Database database; private final Logger logger; @Autowired public UserRepositoryImpl(Database database, Logger logger) { this.database = database; this.logger = logger; } @Override public Optional findById(String id) { logger.log("Finding user: " + id); List results = database.query( "SELECT * FROM users WHERE id = ?", User.class); return results.isEmpty() ? Optional.empty() : Optional.of(results.get(0)); } @Override public void save(User user) { logger.log("Saving user: " + user.getId()); database.query("INSERT INTO users VALUES (?)", Void.class); } } @Service public class UserServiceImpl implements UserService { private final UserRepository userRepository; private final Logger logger; @Autowired public UserServiceImpl(UserRepository userRepository, Logger logger) { this.userRepository = userRepository; this.logger = logger; } @Override public User getUser(String id) { logger.log("Getting user: " + id); return userRepository.findById(id) .orElseThrow(() -> new UserNotFoundException(id)); } @Override public User createUser(CreateUserDTO data) { logger.log("Creating user: " + data.getEmail()); User user = new User(UUID.randomUUID().toString(), data.getName(), data.getEmail()); userRepository.save(user); return user; } } // Configuration class - THE KEY PART @Configuration public class AppConfiguration { @Bean @Scope("singleton") public Logger logger() { return new ConsoleLogger(); } @Bean @Scope("singleton") public Database database( @Value("${database.connection-string}") String connectionString ) { return new PostgresDatabase(connectionString); } @Bean @Scope("prototype") // New instance per request public UserRepository userRepository(Database database, Logger logger) { return new UserRepositoryImpl(database, logger); } @Bean @Scope("request") // Scoped to HTTP request public UserService userService(UserRepository userRepository, Logger logger) { return new UserServiceImpl(userRepository, logger); } }7d:T1778,// Modular container configuration pattern // Each module handles its own feature's dependencies // Base module interface interface IContainerModule { configure(container: Container): void; } // Infrastructure module - cross-cutting concerns class InfrastructureModule implements IContainerModule { constructor(private config: AppConfiguration) {} configure(container: Container): void { // Logging container.bind(TYPES.ILogger) .to(this.config.environment === 'production' ? CloudwatchLogger : ConsoleLogger) .inSingletonScope(); // Database container.bind(TYPES.IDatabase) .toDynamicValue(() => new PostgresDatabase(this.config.databaseUrl)) .inSingletonScope(); // Caching container.bind(TYPES.ICache) .to(this.config.redisUrl ? RedisCache : InMemoryCache) .inSingletonScope(); // HTTP Client container.bind(TYPES.IHttpClient) .to(AxiosHttpClient) .inSingletonScope(); } } // User management module class UserModule implements IContainerModule { configure(container: Container): void { // Repositories container.bind(TYPES.IUserRepository) .to(UserRepository) .inRequestScope(); container.bind(TYPES.IUserProfileRepository) .to(UserProfileRepository) .inRequestScope(); // Services container.bind(TYPES.IUserService) .to(UserService) .inRequestScope(); container.bind(TYPES.IAuthenticationService) .to(JwtAuthenticationService) .inSingletonScope(); container.bind(TYPES.IPasswordHasher) .to(BcryptPasswordHasher) .inSingletonScope(); // Event handlers container.bind>(TYPES.IEventHandler) .to(SendWelcomeEmailHandler) .inTransientScope(); container.bind>(TYPES.IEventHandler) .to(CreateUserProfileHandler) .inTransientScope(); } } // Payment module class PaymentModule implements IContainerModule { constructor(private config: PaymentConfiguration) {} configure(container: Container): void { // Payment provider strategy const paymentProvider = this.createPaymentProvider(); container.bind(TYPES.IPaymentProvider) .toConstantValue(paymentProvider); container.bind(TYPES.IPaymentService) .to(PaymentService) .inRequestScope(); container.bind(TYPES.IRefundService) .to(RefundService) .inRequestScope(); container.bind(TYPES.IInvoiceGenerator) .to(PdfInvoiceGenerator) .inTransientScope(); } private createPaymentProvider(): IPaymentProvider { switch (this.config.provider) { case 'stripe': return new StripePaymentProvider(this.config.stripeKey); case 'paypal': return new PayPalPaymentProvider(this.config.paypalConfig); case 'mock': return new MockPaymentProvider(); default: throw new Error(`Unknown provider: ${this.config.provider}`); } } } // Notification module class NotificationModule implements IContainerModule { configure(container: Container): void { container.bind(TYPES.IEmailSender) .to(SendGridEmailSender) .inSingletonScope(); container.bind(TYPES.ISmsSender) .to(TwilioSmsSender) .inSingletonScope(); container.bind(TYPES.IPushNotificationSender) .to(FirebasePushSender) .inSingletonScope(); container.bind(TYPES.INotificationService) .to(MultiChannelNotificationService) .inRequestScope(); } } // Composition Root - assembles all modules class ApplicationContainer { private container: Container; constructor(private config: AppConfiguration) { this.container = new Container(); } configure(): Container { const modules: IContainerModule[] = [ new InfrastructureModule(this.config), new UserModule(), new PaymentModule(this.config.payment), new NotificationModule(), // Add new feature modules here ]; // Apply all modules modules.forEach(module => module.configure(this.container)); // Verify configuration (fail fast on missing dependencies) this.verifyConfiguration(); return this.container; } private verifyConfiguration(): void { // Attempt to resolve key services to catch configuration errors early const criticalServices = [ TYPES.ILogger, TYPES.IDatabase, TYPES.IUserService, TYPES.IPaymentService, ]; for (const serviceType of criticalServices) { try { this.container.get(serviceType); } catch (error) { throw new ConfigurationError( `Failed to resolve ${serviceType.toString()}: ${error}` ); } } } } // Application startup const config = loadConfiguration(); const appContainer = new ApplicationContainer(config); const container = appContainer.configure();7e:T11aa,// C# Modular configuration with IServiceCollection extensions // Each module is an extension method organizing related registrations public static class InfrastructureModule { public static IServiceCollection AddInfrastructure( this IServiceCollection services, IConfiguration configuration, IWebHostEnvironment environment) { // Logging - different implementations per environment if (environment.IsProduction()) { services.AddSingleton(); } else { services.AddSingleton(); } // Database services.AddSingleton(sp => new PostgresDatabase( configuration.GetConnectionString("Default")! ) ); // Caching var redisConnection = configuration.GetConnectionString("Redis"); if (!string.IsNullOrEmpty(redisConnection)) { services.AddSingleton(sp => new RedisCache(redisConnection)); } else { services.AddSingleton(); } // HTTP Client with resilience services.AddHttpClient() .AddPolicyHandler(GetRetryPolicy()) .AddPolicyHandler(GetCircuitBreakerPolicy()); return services; } } public static class UserModule { public static IServiceCollection AddUserManagement( this IServiceCollection services) { // Repositories services.AddScoped(); services.AddScoped(); // Services services.AddScoped(); services.AddSingleton(); services.AddSingleton(); // Event handlers services.AddTransient, SendWelcomeEmailHandler>(); services.AddTransient, CreateUserProfileHandler>(); // Validators services.AddTransient, CreateUserValidator>(); return services; } } public static class PaymentModule { public static IServiceCollection AddPayments( this IServiceCollection services, PaymentConfiguration config) { // Payment provider - factory pattern for provider selection services.AddSingleton(sp => { return config.Provider switch { "stripe" => new StripePaymentProvider(config.StripeKey), "paypal" => new PayPalPaymentProvider(config.PayPalConfig), "mock" => new MockPaymentProvider(), _ => throw new ArgumentException($"Unknown provider: {config.Provider}") }; }); services.AddScoped(); services.AddScoped(); services.AddTransient(); return services; } } public static class NotificationModule { public static IServiceCollection AddNotifications( this IServiceCollection services, NotificationConfiguration config) { services.AddSingleton(sp => new SendGridEmailSender(config.SendGridApiKey)); services.AddSingleton(sp => new TwilioSmsSender(config.TwilioConfig)); services.AddSingleton(sp => new FirebasePushSender(config.FirebaseConfig)); services.AddScoped(); return services; } } // Program.cs - Composition Root var builder = WebApplication.CreateBuilder(args); var config = builder.Configuration; // Apply all modules builder.Services .AddInfrastructure(config, builder.Environment) .AddUserManagement() .AddPayments(config.GetSection("Payment").Get()!) .AddNotifications(config.GetSection("Notifications").Get()!); // Verify configuration at startup var sp = builder.Services.BuildServiceProvider(); VerifyConfiguration(sp); var app = builder.Build();7f:T1609,// Advanced registration patterns // 1. CONDITIONAL REGISTRATION // Select implementation based on environment or configuration class EnvironmentAwareRegistrar { constructor( private container: Container, private environment: 'development' | 'staging' | 'production' ) {} registerLogger(): void { switch (this.environment) { case 'development': this.container.bind(TYPES.ILogger) .to(PrettyConsoleLogger) .inSingletonScope(); break; case 'staging': this.container.bind(TYPES.ILogger) .to(JsonConsoleLogger) // Structured logging for log aggregation .inSingletonScope(); break; case 'production': this.container.bind(TYPES.ILogger) .to(CloudWatchLogger) .inSingletonScope(); break; } } registerCache(): void { if (this.environment === 'development') { // In-memory cache for fast local development this.container.bind(TYPES.ICache) .to(InMemoryCache) .inSingletonScope(); } else { // Redis for shared state across instances this.container.bind(TYPES.ICache) .toDynamicValue(ctx => { const config = ctx.container.get(TYPES.AppConfig); return new RedisCache(config.redisUrl); }) .inSingletonScope(); } } } // 2. FACTORY REGISTRATION // Complex object construction with dependencies container.bind(TYPES.IPaymentGateway) .toDynamicValue(ctx => { const config = ctx.container.get(TYPES.PaymentConfig); const logger = ctx.container.get(TYPES.ILogger); const metrics = ctx.container.get(TYPES.IMetrics); // Complex initialization logic const gateway = PaymentGatewayFactory.create({ provider: config.provider, apiKey: config.apiKey, webhookSecret: config.webhookSecret, timeoutMs: config.timeoutMs, }); // Wrap with observability return new ObservablePaymentGateway(gateway, logger, metrics); }) .inSingletonScope(); // 3. DECORATOR PATTERN REGISTRATION // Layer behaviors: Core -> Caching -> Logging -> Retry // Start with base implementation container.bind(TYPES.BaseUserRepository) .to(PostgresUserRepository) .inRequestScope(); // Add caching layer container.bind(TYPES.CachedUserRepository) .toDynamicValue(ctx => { const base = ctx.container.get(TYPES.BaseUserRepository); const cache = ctx.container.get(TYPES.ICache); return new CachingUserRepository(base, cache, { ttlSeconds: 300, keyPrefix: 'user:', }); }) .inRequestScope(); // Add logging layer container.bind(TYPES.LoggedUserRepository) .toDynamicValue(ctx => { const cached = ctx.container.get(TYPES.CachedUserRepository); const logger = ctx.container.get(TYPES.ILogger); return new LoggingUserRepository(cached, logger); }) .inRequestScope(); // The "public" binding uses the full decorator chain container.bind(TYPES.IUserRepository) .toDynamicValue(ctx => ctx.container.get(TYPES.LoggedUserRepository)) .inRequestScope(); // 4. NAMED/KEYED REGISTRATIONS // Multiple implementations of the same interface container.bind(TYPES.INotificationChannel) .to(EmailNotificationChannel) .whenTargetNamed('email'); container.bind(TYPES.INotificationChannel) .to(SmsNotificationChannel) .whenTargetNamed('sms'); container.bind(TYPES.INotificationChannel) .to(PushNotificationChannel) .whenTargetNamed('push'); // Injection with named dependencies @injectable() class MultiChannelNotificationService implements INotificationService { constructor( @inject(TYPES.INotificationChannel) @named('email') private emailChannel: INotificationChannel, @inject(TYPES.INotificationChannel) @named('sms') private smsChannel: INotificationChannel, @inject(TYPES.INotificationChannel) @named('push') private pushChannel: INotificationChannel, ) {} async notify(userId: string, message: Notification): Promise { const user = await this.getUser(userId); const channels = this.getPreferredChannels(user); await Promise.all( channels.map(channel => channel.send(userId, message)) ); } } // 5. COLLECTION REGISTRATION // Inject all implementations of an interface container.bind(TYPES.IEventHandler) .to(LoggingEventHandler); container.bind(TYPES.IEventHandler) .to(MetricsEventHandler); container.bind(TYPES.IEventHandler) .to(AuditEventHandler); // Inject all handlers @injectable() class EventDispatcher { constructor( @multiInject(TYPES.IEventHandler) private handlers: IEventHandler[] ) {} async dispatch(event: DomainEvent): Promise { await Promise.all( this.handlers.map(h => h.handle(event)) ); } }72:{"json":{"id":"seed_e522f6459417ec997d1f37627f3b4313","slug":"ioc-container-deep-dive","category":"System Design (LLD)","topic":"IoC Container Deep Dive","title":"IoC Container Deep Dive","description":"Master the intricacies of Inversion of Control containers. Learn to configure containers effectively, understand registration patterns, and apply best practices that enable flexible, testable, and maintainable software architectures.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_38eb504548f1868d3f1cae106694ade3","title":"Container Configuration Approaches","order":0,"content":[{"id":"opening-hook","title":"The Backbone of Modern Dependency Injection","content":[{"data":{"content":"An **Inversion of Control (IoC) container** is the engine that powers dependency injection at scale. While you can hand-wire dependencies manually in small applications, real-world systems with hundreds or thousands of classes demand automated, systematic management of object creation, lifecycle control, and dependency resolution.\n\nThe container serves as a **central registry** that knows how to construct every object in your system, including all their dependencies, their dependencies' dependencies, and so on—forming complete object graphs with zero manual plumbing from application code.\n\nBut containers don't just magically know these things. They must be **configured**—told which implementations fulfill which abstractions, how long objects should live, and when special construction logic applies."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will master the fundamental approaches to configuring IoC containers: imperative (code-based), declarative (XML/config), attribute-based, and convention-based. You'll understand the philosophy behind each approach, their strengths and weaknesses, and how to choose appropriately for your context.","variant":"info"},"type":"callout"}]},{"id":"core-configuration-challenge","title":"The Core Configuration Challenge","content":[{"data":{"content":"At its heart, container configuration answers three fundamental questions:\n\n1. **Registration**: Which concrete types implement which abstractions?\n2. **Lifecycle**: How long should each registered type live (transient, scoped, singleton)?\n3. **Resolution**: How should the container construct objects requiring special handling?\n\nEvery configuration approach addresses these questions differently, with varying trade-offs between flexibility, explicitness, and convenience."},"type":"text"},{"data":{"rows":[["Imperative (Code)","Source code methods","Compile-time","IDE support","Maximum"],["Declarative (XML/JSON)","External config files","None","Schema validation","Runtime flexibility"],["Attribute-based","Decorated classes","Compile-time","Attribute discovery","Moderate"],["Convention-based","Naming/namespace patterns","Compile-time","Automatic","Low (by design)"]],"caption":"Configuration Approaches Overview","headers":["Approach","Configuration Source","Type Safety","Discoverability","Flexibility"]},"type":"table"},{"data":{"content":"Understanding these approaches isn't merely academic—it directly impacts your system's **maintainability**, **debuggability**, and **team velocity**. The wrong choice can create configuration nightmares that haunt projects for years."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"imperative-configuration","title":"Imperative (Code-Based) Configuration","content":[{"data":{"content":"**Imperative configuration** means writing explicit code that tells the container exactly what to do. This is the most common approach in modern frameworks and provides maximum control.\n\n**The Philosophy:**\n\nYour dependency configuration is code—first-class code that compiles, gets refactored by your IDE, and benefits from type checking. There are no magic strings, no external files to keep synchronized, and no runtime surprises from typos."},"type":"text"},{"data":{"fileName":"ContainerConfiguration.ts","languages":[{"code":"$7a","label":"TypeScript","value":"typescript"},{"code":"$7b","label":"C#","value":"csharp"},{"code":"$7c","label":"Java","value":"java"}]},"type":"code"},{"data":{"items":["**Compile-time type safety** — Typos and incorrect type mappings are caught immediately during compilation, not at runtime.","**IDE support** — Full refactoring, auto-completion, and navigation. Rename an interface and all registrations update automatically.","**Conditional logic** — Register different implementations based on environment, configuration flags, or runtime conditions.","**Debuggability** — Set breakpoints in configuration code, step through registration, understand exactly what's happening.","**Version control friendly** — Configuration changes are tracked like any other code change with full diff support."],"title":{"icon":"CheckCircle","text":"Advantages of Imperative Configuration","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"Lightbulb","title":"The Composition Root Pattern","content":"Place all container configuration in a single location—the **Composition Root**—typically at application startup. This creates a single point of truth for your object graph, making the system easier to understand and modify. Never configure the container from multiple scattered locations.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"configuration-modules","title":"Configuration Modules and Organization","content":[{"data":{"content":"As applications grow, placing hundreds of registrations in a single method becomes unwieldy. The solution is **modular configuration**—organizing registrations into cohesive, feature-focused modules.\n\n**The Architecture of Configuration Modules:**\n\nThink of your application as a collection of **vertical slices** or **bounded contexts**. Each slice has its own services, repositories, and handlers. Configuration modules mirror this structure, grouping related registrations together."},"type":"text"},{"data":{"fileName":"ModularConfiguration.ts","languages":[{"code":"$7d","label":"TypeScript","value":"typescript"},{"code":"$7e","label":"C#","value":"csharp"}]},"type":"code"},{"data":{"icon":"Info","title":"Module Boundaries Mirror Domain Boundaries","content":"Configuration modules should align with your domain's bounded contexts or feature areas. A `PaymentModule` contains everything payment-related; a `UserModule` contains authentication, profiles, and user management. This organization makes it obvious where to add new registrations and simplifies reasoning about the system.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"conditional-factory-registration","title":"Conditional and Factory Registration","content":[{"data":{"content":"Real applications require more than simple type-to-type mappings. You often need:\n\n- **Conditional registration**: Different implementations based on environment, configuration, or feature flags\n- **Factory registration**: Complex construction logic that goes beyond simple `new` invocations\n- **Decorator chains**: Layered behaviors wrapping core implementations\n- **Named registrations**: Multiple implementations of the same interface for different purposes"},"type":"text"},{"data":{"fileName":"AdvancedRegistration.ts","languages":[{"code":"$7f","label":"TypeScript","value":"typescript"}]},"type":"code"},{"data":{"items":["**Overcomplicating factories** — If your factory requires injecting 10+ dependencies, your class probably has too many responsibilities. Refactor first.","**Nested container resolution** — Avoid calling `container.get()` from within factory methods unless absolutely necessary. Prefer constructor injection.","**Circular decorator chains** — Ensure decorator layers don't accidentally form cycles. Use explicit binding names to prevent confusion.","**Leaking container references** — The container should only be accessed in the Composition Root, never in business logic."],"title":{"icon":"AlertCircle","text":"Common Pitfalls to Avoid","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"}],"titleType":"number","titleNumber":4},{"id":"when-to-choose-code-config","title":"When to Choose Code-Based Configuration","content":[{"data":{"content":"Imperative configuration is the **default recommendation** for most modern applications. It should be your starting point unless you have specific requirements that demand alternatives."},"type":"text"},{"data":{"left":[{"data":{"items":["**Team has strong typing culture** — Teams that value compiler assistance and IDE support will thrive with code-based config.","**Complex conditional logic** — When implementation choice depends on multiple factors, code handles this naturally.","**Testing is a priority** — Code configuration is trivially unit-testable; you can verify registration logic programmatically.","**Single deployment artifact** — When you deploy a single compiled application rather than swapping configurations.","**New projects** — Start here; migrate to alternatives only if specific needs arise."],"title":{"icon":"CheckCircle","text":"Choose Code Configuration When","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["**Non-developer configuration** — Operators need to swap implementations without code changes or recompilation.","**Plugin architecture** — Third parties extend your system with new implementations unknown at compile time.","**Dynamic reconfiguration** — System must change behavior without restart based on external signals.","**Legacy integration** — Existing systems mandate XML configuration for consistency."],"title":{"icon":"XCircle","text":"Reconsider When","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"icon":"Lightbulb","title":"The Hybrid Approach","content":"Many production systems combine approaches: code-based configuration for the core object graph with external configuration (environment variables, JSON files) for values that genuinely vary across deployments—connection strings, API keys, feature flags. The structure stays in code; the values come from configuration.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"summary","title":"Summary: Container Configuration Approaches","content":[{"data":{"content":"We've explored the foundational concepts of IoC container configuration, focusing on the dominant **imperative (code-based)** approach. Let's consolidate the key insights:"},"type":"text"},{"data":{"type":"ordered","items":["**Container configuration answers registration, lifecycle, and resolution** — Which implementations fulfill abstractions, how long they live, and how they're constructed.","**Imperative configuration provides maximum control** — Compile-time safety, IDE support, refactoring, debugging, and conditional logic.","**Organize configuration into feature modules** — Mirror your domain structure to keep configuration manageable at scale.","**Master advanced patterns** — Factories, decorators, named registrations, and collection injection enable sophisticated architectures.","**Configuration is code—treat it accordingly** — Test it, review it, version it, and refactor it."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nWith the foundation of configuration approaches established, the next page dives into the three major configuration paradigms in detail: **XML vs Code vs Attribute Configuration**. We'll examine each approach's philosophy, implementation patterns, and scenarios where each excels."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the core challenge of container configuration and the dominant imperative approach. You can structure modular configurations, implement advanced patterns like decorators and factories, and make informed decisions about when code-based configuration is appropriate.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":6}],"isLocked":false},{"id":"seed_50b84fdf51fd09563f740416307d1e04","title":"XML vs Code vs Attribute Configuration","order":1,"content":null,"isLocked":true},{"id":"seed_79d23db1666652b8799f5f9bb9c3329c","title":"Automatic Registration Patterns","order":2,"content":null,"isLocked":true},{"id":"seed_ae94f5e79200c85d877cb28c88672582","title":"Container Best Practices","order":3,"content":null,"isLocked":true}]}}