Welke benaderingen worden gebruikt om het principe…

Het Dependency Inversion Principle (DIP) stelt dat:

Hoog-niveau modules niet direct afhankelijk moeten zijn van laag-niveau modules.
Beide typen modules afhankelijk moeten zijn van abstracties (bijvoorbeeld interfaces).
Abstracties niet afhankelijk moeten zijn van details, details afhankelijk moeten zijn van abstracties.

Om dit principe in C# te volgen, worden de volgende benaderingen toegepast:

Gebruik van interfaces en abstracte klassen
- Afhankelijkheden worden gedeclareerd via interfaces, niet via concrete implementaties.
Dependency Injection (DI)
- Afhankelijkheden worden van buiten de klasse doorgegeven (via de constructor, eigenschappen of methoden), en niet binnen de klasse gemaakt.
- Dit maakt het gemakkelijk om implementaties te vervangen en tests te vereenvoudigen.
Inversie van controle (Inversion of Control, IoC)
- Het controle over het maken en koppelen van objecten wordt overgedragen aan een externe container of framework.
Gebruik van DI-containers
- Bijvoorbeeld Microsoft.Extensions.DependencyInjection, Autofac, Ninject, enz.
- Zij beheren de levenscyclus en het oplossen van afhankelijkheden.

Voorbeeld van dependency injection via de constructor:

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

public class UserService
{
    private readonly ILogger _logger;

    public UserService(ILogger logger)
    {
        _logger = logger;
    }

    public void CreateUser(string name)
    {
        // logica voor het aanmaken van een gebruiker
        _logger.Log($"Gebruiker {name} is aangemaakt.");
    }
}

In dit voorbeeld hangt UserService af van de abstractie ILogger, en de concrete implementatie ConsoleLogger wordt van buitenaf doorgegeven, wat overeenkomt met het principe van inversie van afhankelijkheden.

Welke benaderingen worden gebruikt om het principe van afhankelijkheidsomkering na te leven?