Wat is het belangrijkste verschil tussen Dependency Inversion en Dependency Injection?

Dependancy Inversie (principe van afhankelijkheidsomkering) is een van de SOLID-principes, die stelt dat high-level modules niet afhankelijk moeten zijn van low-level modules, maar beide afhankelijk moeten zijn van abstracties. Abstracties moeten niet afhankelijk zijn van details, details moeten afhankelijk zijn van abstracties.

Dependency Injection is een concreet patroon of techniek die het principe van afhankelijkheidsomkering implementeert. Het is een manier om afhankelijkheden (objecten) van buitenaf aan een klasse of functie door te geven, in plaats van ze intern te creëren.

In andere woorden:

• Dependancy Inversie is een concept of ontwerpprincipe.
• Dependency Injection is een manier om dit concept te implementeren, waarbij afhankelijkheden van buitenaf worden doorgegeven.

Voorbeeld in Go:

// Abstractie
 type Notifier interface {
    Notify(message string)
}

// Concrete implementatie
 type EmailNotifier struct {}

func (e EmailNotifier) Notify(message string) {
    fmt.Println("Verzenden email met bericht:", message)
}

// Hoog niveau module
 type UserService struct {
    notifier Notifier // afhankelijk van abstractie
}

// Dependency Injection via constructor
func NewUserService(n Notifier) *UserService {
    return &UserService{notifier: n}
}

func (s *UserService) RegisterUser(name string) {
    // registratie logica
    s.notifier.Notify("Gebruiker geregistreerd: " + name)
}

Hier wordt het principe van afhankelijkheidsomkering nageleefd door afhankelijkheid van de interface Notifier, en dependency injection wordt gedaan door een concrete implementatie van EmailNotifier door te geven aan de constructor van UserService.