Qaysi mexanizmlar bog'liqliklarni teskari qilish…

Ba'zi bog'liq mexanizmlar yordamida bog'liqliklarni teskari qilish prinsipi (Dependency Inversion Principle - DIP) bajariladi:

Abstraktsiyalar:
- Interfeyslar va abstrakt sinflar shartnomalarni belgilaydi, aniq implementatsiyalar emas. Yuqori darajadagi modullar ushbu abstraktsiyalarga bog'liq, past darajadagi aniq sinflarga emas.

Bog'liqliklarni inject qilish (Dependency Injection - DI):

Bir sinf o'z bog'liqliklarini to'g'ridan-to'g'ri yaratish o'rniga, ularni tashqaridan uzatadi. Bu bog'liqliklarning implementatsiyalarini o'zgartirmasdan o'zgartirish imkonini beradi.

C# sintaksisi konstruktor orqali inject qilish uchun:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Abstraksiyaga bog'liqlik

    public HighLevelModule(ILowLevelDependency dependency) // Konstruktor orqali inject
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Abstraksiyadan bog'liqlikni foydalanish
    }
}

C# sintaksisi xususiyat orqali inject qilish uchun:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Xususiyat orqali inject

    public void PerformAction()
    {
        Dependency?.Execute(); // Abstraksiyadan bog'liqlikni foydalanish
    }
}

C# sintaksisi metod orqali inject qilish uchun:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Metod orqali inject
    {
        dependency.Execute(); // Abstraksiyadan bog'liqlikni foydalanish
    }
}

IoC konteynerlar (Inversion of Control Containers):

Frameworklar bog'liqliklarni boshqarish va inject qilish jarayonini avtomatlashtiradi. Ular sinf instansiyalarini yaratadi va ularning bog'liqliklarini sozlangan qoidalarga muvofiq hal qiladi.

Mashhur IoC konteyneridan foydalanish misoli (masalan, StructureMap):

// Bog'liqlikni ro'yxatdan o'tkazish
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Abstraksiyani va uning aniq implementatsiyasini ro'yxatdan o'tkazish
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Bog'liqliklar hal qilingan sinf instansiyasini olish
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Fabrikalar:

Boshqa sinflarning instansiyalarini yaratadigan sinflar. Ular aniq implementatsiyalar yaratish tafsilotlarini yashirishi va abstraktsiyalarni qaytarishi mumkin.

Fabrikadan foydalanish uchun C# sintaksisi misoli:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Aniq implementatsiya yaratish
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Fabrika inject
    {
        _dependency = factory.Create(); // Fabrika yordamida bog'liqlikni yaratish
    }

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

Demeter qonuni (Law of Demeter):
- Garchi bu DIPning to'g'ridan-to'g'ri mexanizmi bo'lmasa-da, bu prinsipga rioya qilish (faqat "o'z do'stlaringiz bilan" gaplashish) odatda to'g'ridan-to'g'ri bog'liqliklarni kamaytiradi va DIPni qo'llashni osonlashtiradi.

Qaysi mexanizmlar bog'liqliklarni teskari qilish prinsipini saqlashga yordam beradi?