Wat is het verschil tussen Dependency Injection en Dependency Inversion?

Dependency Injection (DI) en Dependency Inversion (DIP) zijn gerelateerde, maar verschillende concepten in het veld van softwareontwerp.

• Dependency Inversion Principle (DIP) — een van de vijf SOLID-principes. Het zegt dat:

  1. Hoog-niveau modules niet afhankelijk moeten zijn van laag-niveau modules. Beide moeten afhankelijk zijn van abstracties.
  2. Abstracties mogen niet afhankelijk zijn van details. Details moeten afhankelijk zijn van abstracties.

  Dit principe is gericht op het verminderen van koppeling en het vergroten van de flexibiliteit van de architectuur.

• Dependency Injection (DI) — is een patroon (methode) om de inversie van afhankelijkheden te implementeren. DI betekent dat de afhankelijkheden van een object van buitenaf worden doorgegeven (bijvoorbeeld via de constructor, een setter of een interface), in plaats van binnen het object te worden gemaakt.

Voorbeeld van DI in C++:

class ILogger {
public:
    virtual void Log(const std::string& message) = 0;
};

class ConsoleLogger : public ILogger {
public:
    void Log(const std::string& message) override {
        std::cout << message << std::endl;
    }
};

class Application {
    ILogger& logger;
public:
    Application(ILogger& logger) : logger(logger) {}
    void Run() {
        logger.Log("Applicatie gestart");
    }
};

int main() {
    ConsoleLogger logger;
    Application app(logger); // afhankelijkheid injectie
    app.Run();
}

Kort samengevat: DIP is een ontwerpprincipe, en DI is een manier om het te implementeren.