Quali meccanismi aiutano a rispettare il principio di…

Il principio di inversione delle dipendenze (Dependency Inversion Principle - DIP) viene rispettato attraverso diversi meccanismi interconnessi:

Astrazioni:
- Le interfacce e le classi astratte definiscono contratti, non implementazioni concrete. I moduli di alto livello dipendono da queste astrazioni, non da classi concrete di basso livello.

Iniezione di dipendenze (Dependency Injection - DI):

Invece che una classe crei direttamente le proprie dipendenze, queste vengono passate dall'esterno. Ciò permette di sostituire facilmente le implementazioni delle dipendenze senza modificare il codice della classe.

Sintassi C# per l'iniezione tramite il costruttore:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Dipendenza dall'astrazione

    public HighLevelModule(ILowLevelDependency dependency) // Iniezione tramite il costruttore
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Uso della dipendenza tramite l'astrazione
    }
}

Sintassi C# per l'iniezione tramite proprietà:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Iniezione tramite proprietà

    public void PerformAction()
    {
        Dependency?.Execute(); // Uso della dipendenza tramite l'astrazione
    }
}

Sintassi C# per l'iniezione tramite metodo:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Iniezione tramite metodo
    {
        dependency.Execute(); // Uso della dipendenza tramite l'astrazione
    }
}

Contenitori IoC (Inversion of Control Containers):

Frameworks che automatizzano il processo di gestione e iniezione delle dipendenze. Creano istanze di classi e risolvono le loro dipendenze secondo regole configurate.

Esempio di utilizzo di un contenitore IoC popolare (ad esempio, StructureMap):

// Registrazione della dipendenza
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Registrazione dell'astrazione e della sua implementazione concreta
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Ottenimento di un'istanza della classe con dipendenze risolte
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Fabbriche:

Classi che si occupano di creare istanze di altre classi. Possono nascondere i dettagli di creazione di implementazioni concrete e restituire astrazioni.

Sintassi C# per esempio di utilizzo di una fabbrica:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Creazione di un'implementazione concreta
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Iniezione della fabbrica
    {
        _dependency = factory.Create(); // Uso della fabbrica per creare la dipendenza
    }

    public void PerformAction()
    {
        _dependency.Execute();
    }
}

Legge di Demeter (Law of Demeter):
- Sebbene non sia un meccanismo diretto del DIP, seguire questo principio (parlare solo con "i propri amici") spesso riduce le dipendenze dirette e facilita l'applicazione del DIP.

Quali meccanismi aiutano a rispettare il principio di inversione delle dipendenze?