Dependency Injection (DI) - Managing Dependencies Effectively

Dependency Injection (DI) is a design pattern and a form of Inversion of Control (IoC) where an object receives its dependencies from an external source rather than creating them itself. DI promotes loose coupling, testability, and modularity.

---

Types of Dependency Injection

Constructor Injection

Dependencies are provided through a class constructor.

Setter Injection

Dependencies are provided through setter methods.

Interface Injection

Dependencies are provided through an interface method.

---

How DI Works

1. Define Dependencies: Identify the dependencies a class needs.
2. Inject Dependencies: Provide those dependencies from an external source (e.g., a DI container).
3. Use Dependencies: The class uses the injected dependencies without knowing how they are created.

---

DI in Different Languages

Java (Spring)

// Constructor Injection
@Service
public class UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

// Setter Injection
@Service
public class UserService {
    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

C# (.NET Core)

// Constructor Injection
public class UserService
{
    private readonly IUserRepository _userRepository;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }
}

// Registering Dependencies in Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IUserRepository, UserRepository>();
    services.AddScoped<UserService>();
}

JavaScript (NestJS)

// Constructor Injection
@Controller('users')
export class UserController {
    constructor(private userService: UserService) {}

    @Get()
    findAll() {
        return this.userService.findAll();
    }
}

// Registering Dependencies in a Module
@Module({
    providers: [UserService, UserRepository],
    controllers: [UserController],
})
export class AppModule {}

---

DI for Beginners

Tip

• Start with constructor injection, as it is the most straightforward and widely used.
• Use a DI container to manage dependencies automatically.
• Focus on how DI makes your code more testable and modular.

---

DI for Experienced Developers

Tip

• Explore lifetime management (e.g., transient, scoped, singleton) in DI containers.
• Use DI to manage cross-cutting concerns like logging, caching, and security.
• Consider using property injection or method injection for advanced scenarios.

---

Pros and Cons of DI

Pros	Cons
Reduces coupling between components	Can introduce complexity if overused
Makes applications more testable and modular	Requires learning a DI framework or container
Easier to swap implementations	Can lead to “magic” behavior if not used carefully

---

Next Steps

• Refactor a small project to use DI and observe the benefits.
• Experiment with different types of DI (constructor, setter, interface).