Hoe werkt dependency injection in .NET?

Question

Accepted Answer

**Dependency Injection (DI)** is ingebouwd in modern .NET — het framework bevat een DI-container die automatisch klassen construeert en **hun afhankelijkheden injecteert**. U registreert services (interfaces toewijzen aan implementaties) en de container lost deze op, wat losjes gekoppelde, testbare code mogelijk maakt. Dit is fundamenteel voor ASP.NET Core. ## Services registreren ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` U registreert elke service-mapping waarbij een **interface aan een implementatie** wordt toegewezen met een levensduur. Vervolgens krijgt alles wat van de interface afhankelijk is, de geregistreerde implementatie. ## Constructor injection (het standaardpatroon) ```csharp public class UserService { private readonly IUserRepository _repo; private readonly IEmailSender _email; // dependencies are declared in the constructor — the container INJECTS them automatically public UserService(IUserRepository repo, IEmailSender email) { _repo = repo; _email = email; } } // you never `new UserService(...)` manually — the container builds it, resolving the chain ``` Afhankelijkheden worden gedeclareerd als constructor-parameters (getypeerd als interfaces); de container construeert de klasse en injecteert de geregistreerde implementaties, waarbij de hele afhankelijkheidsgrafiek automatisch wordt opgelost. ## Service lifetimes (belangrijk om correct te kiezen) ```text Singleton → ONE instance for the entire app lifetime (shared; must be thread-safe) Scoped → one instance PER request (the common default for web — e.g. DbContext) Transient → a NEW instance every time it's requested (lightweight, stateless services) → Choosing wrong (e.g. a singleton capturing a scoped DbContext) causes subtle bugs. ``` ## De voordelen: losse koppeling en testbaarheid ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Waarom het belangrijk is Dependency injection is fundamenteel voor modern .NET — het is **ingebouwd in het framework** en vormt de ruggengraat van ASP.NET Core, dus het begrijpen ervan is essentieel voor elke moderne C#-toepassingsontwikkeling. De ingebouwde DI-container van het framework construeert automatisch klassen en injecteert hun afhankelijkheden (waarbij de hele afhankelijkheidsgrafiek wordt opgelost), dus u registreert services en laat de container alles met elkaar verbinden in plaats van afhankelijkheden handmatig te instantiëren. De kernvoordelen zijn aanzienlijk en centraal aan waarom DI wordt benadrukt: **losse koppeling** (afhankelijk zijn van interfaces in plaats van concrete klassen, zodat implementaties kunnen worden uitgewisseld) en vooral **testbaarheid** (mock-implementaties in tests injecteren in plaats van echte afhankelijkheden zoals databases of e-mailservices — waardoor uitgebreide unit-testing praktisch wordt). Het begrijpen van hoe services worden geregistreerd (interfaces toewijzen aan implementaties), constructor injection (het standaardpatroon), en — belangrijk — de **service lifetimes** (`Singleton`, `Scoped`, `Transient`) is essentieel: het kiezen van de verkeerde levensduur veroorzaakt subtiele, moeilijk op te sporen bugs (bijv. een singleton met een scoped `DbContext`, of thread-safety-problemen met gedeelde singletons), dus het begrijpen wanneer elke levensduur van toepassing is (Scoped per-request voor zaken als DbContext, Singleton voor gedeelde staatloze services, Transient voor lichte) is kritisch. Omdat DI is ingebouwd in .NET, de architectuur van ASP.NET Core ondersteunt, en de sleutel is tot het schrijven van losjes gekoppelde, testbare code, is het beheersen ervan — de container, constructor injection, interface-gebaseerd ontwerp, en vooral de service lifetimes — belangrijk, veel toegepast seniorkennis voor het bouwen van onderhoudbare, testbare moderne C#-toepassingen, en een veelvoorkomend interviewonderwerp.