Ի՞նչ տարբերություն կա կախվածության հակադարձման և կախվածության ներմուծման միջև։

Վերահղման կախվածություն (Dependency Inversion Principle) — դա SOLID-ի մի սկզբունք է, որը ասում է.

1. Վերևի մակարդակի մոդուլները չպետք է կախված լինեն ստորին մակարդակի մոդուլներից: Երկուսն էլ պետք է կախված լինեն աբստրակցիաներից:
2. Աբստրակցիաները չպետք է կախված լինեն մանրամասներից, մանրամասները պետք է կախված լինեն աբստրակցիաներից:

Վերածննդի կախվածություն (Dependency Injection, DI) — դա նախագծման ձևաչափ է, որը հանդիսանում է ինվերտի կախվածության իրականացման մի միջոց: Այն ենթադրում է կախվածությունների (օբյեկտների, որոնցից կախված է այս դասը) փոխանցումը արտաքինից, փոխարենը այն, որ դասը ինքն է ստեղծում դրանք:

Հիմնական տարբերությունները՝

• DIC - նախագծման սկզբունք, DI - նախագծման ձևաչափ:
• DIC - սահմանում է, թե ինչպիսի հարաբերություններ պետք է լինեն բարձր և ցածր մակարդակի մոդուլների միջև (աբստրակցիաներից կախվածություն):
• DI - մեթոդ է, որը թույլ է տալիս իրականացնել այդ հարաբերությունները: Դա կոնկրետ տեխնիկա է կախվածությունների մատակարարման համար օբյեկտին:

Կախվածության ներդրման օրինակներ՝

• Constructor Injection: Կախվածությունները փոխանցվում են կոնստրուկտորով:

  class UserFetcher {
      private let apiService: APIServiceProtocol // Աբստրակցիայից կախվածություն
  
      init(apiService: APIServiceProtocol) { // Ներմուծում կոնստրուկտորով
          self.apiService = apiService
      }
  
      func fetchUsers() {
          // օգտագործում է apiService
      }
  }
  
  protocol APIServiceProtocol {
      // ...
  }
  

• Property Injection: Կախվածությունները սահմանվում են հանրային հատկությունների միջոցով (շատ հաճախ օգտագործելով @IBOutlet կամ անհրաժեշտության դեպքում օպցիոնալ կախվածություն):

  class UserController: UIViewController {
      var userFetcher: UserFetcherProtocol? // Կախվածությունը կարող է սահմանվել արտաքինից
  
      override func viewDidLoad() {
          super.viewDidLoad()
          userFetcher?.fetchUsers()
      }
  }
  
  protocol UserFetcherProtocol {
      func fetchUsers()
  }
  

• Method Injection: Կախվածությունները փոխանցվում են մեթոդների որպես պարամետրեր:

  class DataProcessor {
      func process(data: Data, using parser: DataParserProtocol) { // Կախվածությունը փոխանցվում է մեթոդին
          parser.parse(data)
      }
  }
  
  protocol DataParserProtocol {
      func parse(_ data: Data)
  }
  

Այսպիսով, կախվածության ինվերտը — դա նպատակն է (կորցնել耦合ը աբստրակցիաների միջոցով), իսկ կախվածության ներդրումը — դա միջոցն է (մեկը միջոցներից այս նպատակին հասնելու):