Dependency Injection (DI) is a design pattern used in software development to improve code modularity and testability. It allows a class to receive its dependencies from external sources rather than creating them internally. This approach decouples the code, making it easier to manage and test.
By injecting dependencies, you can switch implementations easily, facilitate unit testing by providing mock dependencies, and promote a clean architecture. Various types of Dependency Injection exist, including constructor injection, setter injection, and interface injection.
<?php
interface Logger {
public function log($message);
}
class FileLogger implements Logger {
public function log($message) {
// Logic to write log to a file
echo "Logging to file: " . $message;
}
}
class Application {
private $logger;
// Constructor injection
public function __construct(Logger $logger) {
$this->logger = $logger;
}
public function run() {
$this->logger->log("Application is running.");
}
}
// Usage
$logger = new FileLogger();
$app = new Application($logger);
$app->run();
?>
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?