Quali approcci vengono utilizzati per rispettare il principio di inversione delle dipendenze?

Il Principio di Inversione delle Dipendenze (Dependency Inversion Principle, DIP) afferma che:

• I moduli di alto livello non devono dipendere direttamente dai moduli di basso livello.
• Entrambi i tipi di moduli devono dipendere da astrazioni (ad esempio, interfacce).
• Le astrazioni non devono dipendere dai dettagli, i dettagli devono dipendere dalle astrazioni.

Per rispettare questo principio in C#, si applicano i seguenti approcci:

1. Utilizzo di interfacce e classi astratte

   • Le dipendenze sono dichiarate tramite interfacce, non implementazioni concrete.

2. Iniezione di dipendenze (Dependency Injection, DI)

   • Le dipendenze vengono passate alla classe dall'esterno (tramite il costruttore, proprietà o metodi), e non create internamente.
   • Questo facilita la sostituzione delle implementazioni e semplifica i test.

3. Inversione del controllo (Inversion of Control, IoC)

   • Il controllo sulla creazione e il binding degli oggetti viene trasferito a un contenitore o framework esterno.

4. Utilizzo di contenitori DI

   • Ad esempio, Microsoft.Extensions.DependencyInjection, Autofac, Ninject, ecc.
   • Gestiscono il ciclo di vita e la risoluzione delle dipendenze.

Esempio di iniezione di dipendenze tramite il costruttore:

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 di creazione utente
        _logger.Log($"Utente {name} creato.");
    }
}

In questo esempio, UserService dipende dall'astrazione ILogger, e l'implementazione concreta ConsoleLogger viene passata dall'esterno, rispettando il principio di inversione delle dipendenze.