Milyen mechanizmusok segítenek betartani az…

A függőség fordított elve (Dependency Inversion Principle - DIP) több összefüggő mechanizmus révén valósul meg:

Absztrakciók:
- Interfészek és absztrakt osztályok szerződéseket határoznak meg, nem konkrét megvalósításokat. A magas szintű modulok ezekre az absztrakciókra támaszkodnak, nem az alacsony szintű konkrét osztályokra.

**Függőség injektálás (Dependency Injection - DI):

Ahelyett, hogy egy osztály közvetlenül hozná létre a függőségeit, azokat kívülről adják át neki. Ez megkönnyíti a függőségek megvalósításának cseréjét anélkül, hogy módosítani kellene az osztály kódját.

C# szintaxis konstruktoron keresztüli injektáláshoz:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Absztrakcióra való függőség

    public HighLevelModule(ILowLevelDependency dependency) // Konstruktoron keresztüli injektálás
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Függőség absztrakció használatával
    }
}

C# szintaxis tulajdonságon keresztüli injektáláshoz:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Tulajdonságon keresztüli injektálás

    public void PerformAction()
    {
        Dependency?.Execute(); // Függőség absztrakció használatával
    }
}

C# szintaxis metóduson keresztüli injektáláshoz:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Metóduson keresztüli injektálás
    {
        dependency.Execute(); // Függőség absztrakció használatával
    }
}

**IoC-konténerek (Inversion of Control Containers):

Keretrendszerek, amelyek automatizálják a függőségek kezelését és injektálását. Ők felelősek az osztálypéldányok létrehozásáért és a függőségek feloldásáért a beállított szabályok szerint.

Egy népszerű IoC-konténer (pl. StructureMap) használatának példája:

// Függőség regisztrálása
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Absztrakció és konkrét megvalósítás regisztrálása
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Az osztály példányának megszerzése a feloldott függőségekkel
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Fabrikák:

Osztályok, amelyek más osztálypéldányokat hoznak létre. Elrejthetik a konkrét megvalósítások létrehozásának részleteit, és absztrakciókat adhatnak vissza.

C# szintaxis a fabrika használatára példaként:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Konkrét megvalósítás létrehozása
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Fabrika injektálása
    {
        _dependency = factory.Create(); // Fabrikát használva a függőség létrehozására
    }

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

A Demeter törvénye (Law of Demeter):
- Bár nem közvetlen DIP mechanizmus, ennek a principiumnak a betartása (csak a közvetlen "barátokkal" beszélgetés) gyakran csökkenti a közvetlen függőségeket, és megkönnyíti a DIP alkalmazását.

Milyen mechanizmusok segítenek betartani az függőségek fordított elvét?