Որ մեխանիզմները օգնում են պահպանել կախվածությունների հակադարձման սկզբունքը?

Ավելի շատ կախվածությունների հակադարձման սկզբունքը (Dependency Inversion Principle - DIP) իրականացվում է մի քանի փոխկապակցված մեխանիզմներով:

1. Աբստրակցիաներ:

   • Ինտերֆեյսները և աբստրակտ դասերը սահմանում են պայմանագրեր, ոչ թե կոնկրետ իրագործումներ: Բարձր մակարդակի մոդուլները կախված են այդ աբստրակցիաներից, ոչ թե ցածր մակարդակի կոնկրետ դասերից:

2. Կախվածությունների ներդրում (Dependency Injection - DI):

   • Փոխարենը, որ դասը ստեղծի իր կախվածությունները ուղղակիորեն, դրանք փոխանցվում են նրան արտաքինից: Սա թույլ է տալիս հեշտությամբ փոխարինել կախվածությունների իրագործումները առանց դասի կոդը փոխելու:
   • C# սինտաքսիս ներդրման համար կոնստրուկտորով:

     public class HighLevelModule
     {
         private readonly ILowLevelDependency _dependency; // Աբստրակցիայի կախվածություն
     
         public HighLevelModule(ILowLevelDependency dependency) // Ներդրում կոնստրուկտորով
         {
             _dependency = dependency;
         }
     
         public void PerformAction()
         {
             _dependency.Execute(); // Կախվածության օգտագործում աբստրակցիայից
         }
     }
     

   • C# սինտաքսիս ներդրման համար հատկությամբ:

     public class AnotherHighLevelModule
     {
         public ILowLevelDependency Dependency { get; set; } // Ներդրում հատկությամբ
     
         public void PerformAction()
         {
             Dependency?.Execute(); // Կախվածության օգտագործում աբստրակցիայից
         }
     }
     

   • C# սինտաքսիս ներդրման համար մեթոդով:

     public class YetAnotherHighLevelModule
     {
         public void PerformAction(ILowLevelDependency dependency) // Ներդրում մեթոդով
         {
             dependency.Execute(); // Կախվածության օգտագործում աբստրակցիայից
         }
     }
     

3. IoC-կոնտեյներներ (Inversion of Control Containers):

   • Ֆրեյմվորկեր, որոնք ավտոմատացնում են կախվածությունների կառավարումը և ներդրումը: Նրանք պատասխանատու են դասերի օրինակների ստեղծման և դրանց կախվածությունների լուծման համար:
   • Օրինակ՝ հայտնի IoC-կոնտեյների օգտագործում (օրինակ՝ StructureMap):

     // Կախվածության գրանցում
     // container.Configure(cfg =>
     // {
     //     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Աբստրակցիայի և նրա կոնկրետ իրագործման գրանցում
     //     cfg.For<HighLevelModule>().Use<HighLevelModule>();
     // });
     
     // Օբյեկտի ստացում՝ կախվածությունների լուծմամբ
     // var highLevelModule = container.GetInstance<HighLevelModule>();
     // highLevelModule.PerformAction();
     

4. Ֆաբրիկաներ:

   • Դասեր, որոնք պատասխանատու են այլ դասերի օրինակների ստեղծման համար: Նրանք կարող են թաքցնել կոնկրետ իրագործումների ստեղծման մանրամասները և վերադարձնել աբստրակցիաներ:
   • C# սինտաքսիս՝ ֆաբրիկայի օգտագործման օրինակ:

     public interface ILowLevelDependencyFactory
     {
         ILowLevelDependency Create();
     }
     
     public class LowLevelDependencyFactory : ILowLevelDependencyFactory
     {
         public ILowLevelDependency Create()
         {
             return new ConcreteLowLevelDependency(); // Կոնկրետ իրագործման ստեղծում
         }
     }
     
     public class HighLevelModuleWithFactory
     {
         private readonly ILowLevelDependency _dependency;
     
         public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Ֆաբրիկայի ներդրում
         {
             _dependency = factory.Create(); // Ֆաբրիկայի օգտագործում կախվածության ստեղծման համար
         }
     
         public void PerformAction()
         {
             _dependency.Execute();
         }
     }
     

5. Լավագույն գիտելիքների օրենքը (Law of Demeter):

   • Թեև դա չի հանդիսանում ուղիղ DIP մեխանիզմ, այս սկզբունքի պահպանումը (խոսել միայն իր անմիջական "ընկերների" հետ) հաճախ հանգեցնում է ուղիղ կախվածությունների նվազեցմանը և, հետևաբար, DIP կիրառման հեշտացման: