Millised mehhanismid aitavad järgida sõltuvuste…

Sõltuvuste pööramise põhimõte (Dependency Inversion Principle - DIP) rakendub mitmete omavahel seotud mehhanismide kaudu:

Abstraktsioonid:
- Liidese ja abstraktsete klasside määratlemine, mis ei defineeri konkreetseid teostusi. Kõrgema taseme moodulid sõltuvad nende abstraktsioonide kaudu, mitte madalama taseme konkreetsetest klassidest:

Sõltuvuste sisestamine (Dependency Injection - DI):

Selle asemel, et klass ise loob oma sõltuvused, antakse need talle väljastpoolt. See võimaldab hõlpsasti asendada sõltuvuste teostusi ilma klassi koodi muutmata:

C# sünntaks konstruktoriga sisestamiseks:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Abstraktsiooni sõltuvus

    public HighLevelModule(ILowLevelDependency dependency) // Sisestus konstruktoriga
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Sõltuvuse kasutamine abstraktsiooni kaudu
    }
}

C# sünntaks omaduse kaudu:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Sisestus omaduse kaudu

    public void PerformAction()
    {
        Dependency?.Execute(); // Sõltuvuse kasutamine abstraktsiooni kaudu
    }
}

C# sünntaks meetodi kaudu:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Sisestus meetodi kaudu
    {
        dependency.Execute(); // Sõltuvuse kasutamine abstraktsiooni kaudu
    }
}

IoC-konteinerid (Inversion of Control Containers):

Raamistikud, mis automatiseerivad sõltuvuste haldamise ja sisestamise. Nad vastutavad klasside eksemplaride loomise ja nende sõltuvuste lahendamise eest vastavalt seatud reeglitele:

Näide populaarse IoC-konteineri kasutamisest (näiteks StructureMap):

// Sõltuvuste registreerimine
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Abstraktsiooni ja selle konkreetse teostuse registreerimine
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Näide klassi eksemplari saamisest sõltuvuste lahendamisega
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Faktorid:

Klasid, mis vastutavad teiste klasside eksemplaride loomise eest. Nad võivad varjata konkreetsete teostuste loomise detaile ja tagastada abstraktsioone:

C# sünntaks fabrika näite kasutamiseks:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Konkreetse teostuse loomine
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Fabrika sisestus
    {
        _dependency = factory.Create(); // Fabrika kasutamine sõltuvuse loomiseks
    }

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

Demeteri seadus (Law of Demeter):
- Kuigi see ei ole otseselt DIP mehhanism, selle põhimõtte järgimine (rääkida ainult oma "sõpradega") sageli viib otseste sõltuvuste vähendamiseni ning seega DIP-i rakendamise lihtsustumiseni:

Millised mehhanismid aitavad järgida sõltuvuste pööramise põhimõtet?