რა მექანიზმები ეხმარება დამოკიდებულების ინვერსიის პრინციპის დაცვას?

დეპენდენცის ინვერსიის პრინციპი (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-ის გამოყენების გამარტივებას: