Antwoord.

Dependency Inversion Principle (DIP) is een architectonisch principe dat stelt dat:

• Module van hoog niveau mogen niet afhankelijk zijn van modules van laag niveau. Beide typen moeten afhankelijk zijn van abstracties (interfaces).
• Abstracties mogen niet afhankelijk zijn van details; details moeten afhankelijk zijn van abstracties.

Dit betekent dat de bedrijfslogica (bijvoorbeeld een service voor het verwerken van bestellingen) niet moet weten van en direct gebruik maken van een specifieke implementatie van infrastructuur (bijvoorbeeld een klasse die e-mailverzending implementeert), maar moet werken via een abstractie (interface) die via een DI-container of handmatig wordt geïnjecteerd.

Voorbeeldcode in C#:

public interface IEmailSender {
    void Send(string to, string message);
}

public class SmtpEmailSender : IEmailSender {
    public void Send(string to, string message) {
        // Implementatie van e-mailverzending
    }
}

public class OrderService {
    private readonly IEmailSender _emailSender;

    public OrderService(IEmailSender emailSender) {
        _emailSender = emailSender;
    }
    public void PlaceOrder(string customer) {
        // bedrijfslogica
        _emailSender.Send(customer, "Uw bestelling is geplaatst!");
    }
}

Belangrijke kenmerken:

• Maakt het gemakkelijk om de implementatiedetails te vervangen (bijvoorbeeld om een mock in tests te injecteren).
• Verhoogt de testbaarheid en uitbreidbaarheid van de architectuur.
• Zorgt voor lage koppeling tussen modules.

Vragen met een valstrik.

Is DIP gewoon afhankelijkheidsinjectie via de constructor?

Nee. DIP gaat over het scheiden van abstracties van implementaties. Afhankelijkheidsinjectie (Dependency Injection, DI) is slechts een hulpmiddel waarmee DIP wordt gerealiseerd. DIP kan ook zonder DI-container worden gerealiseerd door handmatig het scheiden van abstracties en details te waarborgen.

Als u één implementatie van de interface heeft, is DIP dan verplicht?

Ja, het principe is nog steeds toepasbaar, als er mogelijkheid tot uitbreiding is. Het introduceren van abstracties bereidt het systeem voor op wijziging van eisen zonder wijziging van de code op hoog niveau. Zelfs met één implementatie van de interface vergemakkelijkt lage koppeling het testen en de ontwikkeling van het systeem.

Kan DIP worden geschonden door logica in fabrieken of service-locators te gebruiken?

Ja. Als een fabriek of service-locator op de hoogte is van de details van de implementatie en deze dynamisch verbindt zonder gebruik te maken van een interface aan de klantzijde, wordt DIP geschonden, ondanks de externe aanwezigheid van abstracties.