Antwoord.

Het beheer van de levenscyclus van afhankelijkheden is het organiseren van de creatie, initialisatie, update en vernietiging van de applicatiecomponenten op een zodanige manier dat ze onafhankelijk van elkaar zijn en eenvoudig getest kunnen worden. Hiervoor worden vaak IoC-containers (Inversion of Control) en het Dependency Injection (DI) patroon toegepast.

IoC-container stelt in staat:

• Automatisch objecten (componenten) te creëren en met elkaar te verbinden.
• Het levensduur (scope) van elk object te beheren (singleton, transient, scoped).
• Eenvoudige vervangbaarheid van componenten voor testing en schaling te waarborgen.

Voorbeeld in C# met gebruik van Microsoft.Extensions.DependencyInjection:

public interface IMessageSender { void Send(string msg); }
public class EmailSender : IMessageSender {
    public void Send(string msg) { /* email verzenden */ }
}

// Registratie van afhankelijkheden
var services = new ServiceCollection();
services.AddScoped<IMessageSender, EmailSender>();

// Verkrijgen van een instantie
var provider = services.BuildServiceProvider();
var sender = provider.GetService<IMessageSender>();
sender.Send("Hallo!");

Belangrijke kenmerken:

• Maakt een duidelijke scheiding van afhankelijkheden mogelijk en versnelt de ontwikkeling van de architectuur.
• Vergemakkelijkt de testen van componenten door het vervangen van afhankelijkheden (mocks).
• Helpt bij het realiseren van lage koppeling tussen componenten.

Vragen met een addertje onder het gras.

Wat is het verschil tussen dependency injection (DI) en het Service Locator patroon, en waarom wordt Service Locator als een antipatroon beschouwd?

Service Locator doorbreekt de expliciete overdracht van afhankelijkheden, waardoor de code minder transparant wordt. Het is beter om DI via de constructor of methoden te gebruiken, zodat de compiler de correctheid van de afhankelijkheden controleert.

// Slecht: Service Locator
var sender = ServiceLocator.Get<IMessageSender>();

// Goed: via DI
public class MyService {
   public MyService(IMessageSender sender) { ... }
}

Wat is het verschil tussen het Singleton patroon en Single Instance levensduur in de DI-container?

Het Singleton patroon wordt handmatig geïmplementeerd en is niet afhankelijk van de container; Single Instance biedt een instantie vanuit de container, wat veiliger is voor unit tests en extensie.

Moet je afhankelijkheden in alle klassen injecteren, zelfs in eenvoudige hulpprogramma's?

Nee. Hulpprogramma's zonder afhankelijkheden of zwak gekoppelde helper-klassen (bijvoorbeeld een klasse met wiskundige constanten) hoeven geen DI te hebben — dit compliceert de code zonder voordelen te bieden.