Dependency Injection

Dependency Injection is a fundamental design pattern that implements the Inversion of Control (IoC) principle. Instead of a component creating its own dependencies, they are provided from the outside, typically through constructors, setters, or interfaces. This approach dramatically improves code testability, maintainability, and flexibility.

Fundamentals of Dependency Injection

• Strict separation between object creation and object usage
• Inversion of control: dependencies are provided by an external container or framework
• Dependency on abstractions (interfaces) rather than concrete implementations
• Centralized dependency configuration facilitating architectural changes

Benefits of Dependency Injection

• Enhanced testability: facilitates replacing dependencies with mocks or stubs
• Loose coupling: components are independent of concrete dependency implementations
• Reusability: components can be reused in different contexts with different dependencies
• Simplified maintenance: implementation changes without modifying client code
• Adherence to SOLID principles, particularly the Dependency Inversion Principle (DIP)

Practical Example: User Service

// ❌ Without DI: tight coupling
class UserService {
  private repository = new UserRepository();
  private emailer = new EmailService();
  
  createUser(data: UserData) {
    const user = this.repository.save(data);
    this.emailer.send(user.email, 'Welcome!');
  }
}

// ✅ With DI: loose coupling
interface IUserRepository {
  save(data: UserData): User;
}

interface IEmailService {
  send(to: string, message: string): void;
}

class UserService {
  constructor(
    private repository: IUserRepository,
    private emailer: IEmailService
  ) {}
  
  createUser(data: UserData) {
    const user = this.repository.save(data);
    this.emailer.send(user.email, 'Welcome!');
  }
}

// DI container configuration
const container = new DIContainer();
container.register('IUserRepository', UserRepository);
container.register('IEmailService', EmailService);
container.register('UserService', UserService);

// Usage
const userService = container.resolve<UserService>('UserService');

// Easy testing with mocks
const mockRepo = { save: jest.fn() };
const mockEmailer = { send: jest.fn() };
const testService = new UserService(mockRepo, mockEmailer);

Types of Dependency Injection

• Constructor injection: mandatory dependencies passed during instantiation (recommended)
• Setter injection: optional dependencies set after creation
• Interface injection: using interfaces to define injection points
• Property injection: direct injection into public properties (less common)

Implementing a Dependency Injection System

1. Identify each component's dependencies and extract appropriate interfaces
2. Configure a DI container with bindings between interfaces and implementations
3. Modify constructors to accept dependencies via parameters
4. Define lifetime scopes (singleton, transient, scoped) for each dependency
5. Configure auto-wiring if the framework supports it to reduce manual configuration
6. Implement factory methods for complex cases requiring creation logic
7. Add dependency validation at startup to detect configuration errors

Associated Tools and Frameworks

• InversifyJS: powerful DI container for TypeScript/JavaScript with decorator support
• Angular DI: Angular's native injection system with hierarchical injection
• NestJS: Node.js framework with Angular-inspired DI
• Tsyringe: lightweight DI container for TypeScript
• Spring Framework: Java reference with annotation or XML configuration
• ASP.NET Core DI: container integrated with .NET framework
• Dagger: DI framework for Java/Kotlin with compile-time code generation

Advanced Patterns

// Factory Pattern with DI
interface INotificationService {
  notify(message: string): void;
}

class NotificationFactory {
  constructor(private container: DIContainer) {}
  
  create(type: 'email' | 'sms' | 'push'): INotificationService {
    return this.container.resolve<INotificationService>(`${type}NotificationService`);
  }
}

// Decorator Pattern for logging
class LoggingDecorator<T> {
  constructor(private wrapped: T) {}
  
  // Proxy all calls with logging
  static wrap<T>(instance: T): T {
    return new Proxy(instance, {
      get(target, prop) {
        const original = target[prop];
        if (typeof original === 'function') {
          return (...args: any[]) => {
            console.log(`Calling ${String(prop)}`, args);
            const result = original.apply(target, args);
            console.log(`Result:`, result);
            return result;
          };
        }
        return original;
      }
    });
  }
}

// Configuration with scopes
container.register('IUserRepository', UserRepository, { scope: 'singleton' });
container.register('IEmailService', EmailService, { scope: 'transient' });
container.register('INotificationFactory', NotificationFactory, { scope: 'scoped' });

Dependency Injection radically transforms application architectural quality by making code more testable, maintainable, and evolvable. While it introduces initial complexity, the long-term benefits justify this investment for professional development teams.