Ce mecanisme ajută la respectarea principiului…

Principiul inversiunii dependențelor (Dependency Inversion Principle - DIP) este respectat prin mai multe mecanisme interconectate:

Abstracții:
- Interfețele și clasele abstracte definesc contracte, nu implementări concrete. Modulele de nivel înalt depind de aceste abstracții, nu de clase concrete de nivel inferior.

**Injectarea dependențelor (Dependency Injection - DI):

În loc ca o clasă să își creeze dependențele direct, acestea îi sunt transmise din exterior. Acest lucru permite înlocuirea ușoară a implementărilor dependențelor fără a modifica codul clasei.

Sintaxa C# pentru injectare prin constructor:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Dependență de abstracție

    public HighLevelModule(ILowLevelDependency dependency) // Injectare prin constructor
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Utilizarea dependenței prin abstracție
    }
}

Sintaxa C# pentru injectare prin proprietate:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Injectare prin proprietate

    public void PerformAction()
    {
        Dependency?.Execute(); // Utilizarea dependenței prin abstracție
    }
}

Sintaxa C# pentru injectare prin metodă:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Injectare prin metodă
    {
        dependency.Execute(); // Utilizarea dependenței prin abstracție
    }
}

Containere IoC (Inversion of Control Containers):

Framework-uri care automatizează procesul de gestionare a dependențelor și injectare. Ele se ocupă cu crearea instanțelor de clase și rezolvarea dependențelor conform regulilor configurate.

Exemplu de utilizare a unui container IoC popular (de exemplu, StructureMap):

// Înregistrarea dependenței
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Înregistrarea abstracției și implementării sale concrete
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Obținerea unei instanțe a clasei cu dependențe rezolvate
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Fabrica:

Clase care răspund de crearea altor clase. Ele pot ascunde detaliile creării implementărilor concrete și pot returna abstracții.

Sintaxa C# pentru exemplu de utilizare a fabricii:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Crearea unei implementări concrete
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Injectare fabrică
    {
        _dependency = factory.Create(); // Utilizare fabrică pentru crearea dependenței
    }

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

Principiul cunoștințelor minime (Law of Demeter):
- Deși nu este un mecanism direct DIP, respectarea acestui principiu (vorbirea doar cu "prieteni" direcți) duce adesea la reducerea dependențelor directe și, ca urmare, facilitează aplicarea DIP.

Ce mecanisme ajută la respectarea principiului inversiunii dependențelor?