Ի՞նչ մոտեցումներ են օգտագործվում կախվածությունների հակադարձման սկզբունքը պահպանելու համար։

Ավելի բարձր մակարդակի մոդուլները պետք է չպետք է ուղղակիորեն կախված լինեն ցածր մակարդակի մոդուլներից:

• Երկու տեսակի մոդուլներն էլ պետք է կախված լինեն աբստրակցիաներից (օրինակ, ինտերֆեյսներից):
• Աբստրակցիաները չպետք է կախված լինեն մանրամասներից, մանրամասները պետք է կախված լինեն աբստրակցիաներից:

Այս սկզբունքը պահպանելու համար C#-ում կիրառվում են հետևյալ մոտեցումները:

1. Ինտերֆեյսների և աբստրակտ դասերի օգտագործում

   • Dependencies հայտարարում են ինտերֆեյսների միջոցով, ոչ կոնկրետ իրականացումների:

2. Ապավինությունների ներդրում (Dependency Injection, DI)

   • Dependencies փոխանցվում են դասին դուրսից (կառուցիչ, հատկություններ կամ մեթոդներ):
   • Սա հեշտացնում է իրականացումների փոխարինումը և թեստավորումը:

3. Կառավարման հակադարձում (Inversion of Control, IoC)

   • Օբյեկտների ստեղծման և կապակցման վերահսկողությունը փոխանցվում է արտաքին կոնտեյներին կամ ֆրեյմվորկին:

4. DI կոնտեյներ օգտագործում

   • Օրինակ, Microsoft.Extensions.DependencyInjection, Autofac, Ninject և այլն:
   • Նրանք կառավարում են կյանքի ցիկլը և dependencies լուծումը:

Օրինակ, կառուցիչով dependencies ներդնելու համար:

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

public class UserService
{
    private readonly ILogger _logger;

    public UserService(ILogger logger)
    {
        _logger = logger;
    }

    public void CreateUser(string name)
    {
        // օգտագործողի ստեղծման լոգիկա
        _logger.Log($"Օգտագործող {name} ստեղծվեց.");
    }
}

Այս օրինակով, UserService կախված է աբստրակցիայից ILogger, իսկ կոնկրետ իրականացումը ConsoleLogger փոխանցվում է դուրսից, ինչը համապատասխանում է կախվածությունների հակադարձման սկզբունքին։