Wat is dependency injection (DI) in ASP.NET Core?

Afhankelijkheidsinjectie (DI) is een ontwerppatroon voor inversie van controle (IoC), dat het mogelijk maakt om zwak gekoppelde code te creëren. In ASP.NET Core is DI een ingebouwde functie die het beheer van afhankelijkheden tussen klassen vergemakkelijkt.

Belangrijkste componenten van DI in ASP.NET Core:

Services: Objecten die functionaliteit bieden (bijvoorbeeld repository-klassen, loggingsdiensten).
DI-container: Object dat verantwoordelijk is voor het oplossen van afhankelijkheden en het maken van service-instanties.
Levenscyclus van services: Bepaalt wanneer en hoe service-instanties worden gemaakt:
- Transient: Een nieuwe instantie wordt bij elke service-aanvraag gemaakt.
- Scoped: Eén instantie per aanvraag (voor webapplicaties — per HTTP-aanvraag).
- Singleton: Eén instantie wordt bij de eerste aanvraag gemaakt en wordt gedurende de hele levensduur van de applicatie gebruikt.

Voordelen van DI:

Zwakke koppeling: Klassen vertrouwen op abstracties (interfaces), niet op concrete implementaties.
Testbaarheid: Het is gemakkelijk om echte afhankelijkheden te vervangen door "mocks" of "stubs" tijdens unittests.
Uitbreidbaarheid: Het is eenvoudig om implementaties van services te vervangen zonder de afhankelijkheidscode te wijzigen.
Beheer van afhankelijkheden: DI-container beheert de levenscyclus en het maken van instanties.

Voorbeeld van het registreren van services in Startup.cs (of Program.cs in .NET 6+):

// In de ConfigureServices-methode
public void ConfigureServices(IServiceCollection services)
{
    // Registratie van een service met singleton levenscyclus
    services.AddSingleton<ILogger, EmailLogger>();

    // Registratie van een scoped service
    services.AddScoped<IDataRepository, SqlDataRepository>();

    // Registratie van een transient service
    services.AddTransient<ITransientService, TransientService>();

    // Registratie van controllers voor dependency injection
    services.AddControllersWithViews();
}
Injectie van afhankelijkheden in de constructor van de controller:

```csharp
public class HomeController : Controller
{
    private readonly ILogger _logger;
    private readonly IDataRepository _repository;

    // ASP.NET Core DI lost deze afhankelijkheden automatisch op en injecteert ze
    public HomeController(ILogger logger, IDataRepository repository)
    {
        _logger = logger;
        _repository = repository;
    }

    // ... acties van de controller
}