რა შეგიძლია თქვა SOLID-ის პრინციპი D-ის შესახებ?

Dependency Inversion Principle (DIP) ამბობს:

• მაღლა დონის მოდულები არ უნდა იყოს დამოკიდებული ქვედა დონის მოდულებზე. ორივე ტიპის მოდულები უნდა იყოს დამოკიდებული აბსტრაქციებზე.
• აბსტრაქციები არ უნდა იყოს დამოკიდებული დეტალებზე. დეტალები უნდა იყოს დამოკიდებული აბსტრაქციებზე.

SOLID-ის D მიზანია მაღლა დონის პოლიტიკების და დაბლა დონის რეალიზაციის დაშორება (decoupling). ნაცვლად იმისა, რომ მაღლა დონის მოდული პირდაპირ იყოს დამოკიდებული დაბლა დონის კონკრეტულ რეალიზაციაზე, ორივე დამოკიდებულია საერთო ინტერფეისზე ან აბსტრაქტულ კლასზე. ეს ზრდის მოქნილობას, ტესტირებადობას და კოდის შენარჩუნებას.

Flutter-ში ეს ხშირად გამოხატულია აბსტრაქტული კლასების ან მიქსინების გამოყენებით კონტრაქტების განსაზღვრად, რომლებიც შემდეგ რეალიზდება კონკრეტული კლასებით. მაგალითად, მონაცემებთან მუშაობისას:

// აბსტრაქცია
abstract class DataService {
  Future<List<String>> getData();
}

// დაბალი დონის რეალიზაცია (კონკრეტული დეტალი)
class ApiDataService implements DataService {
  @override
  Future<List<String>> getData() async {
    // API-დან მონაცემების მიღების ლოგიკა
    return ['API Data 1', 'API Data 2'];
  }
}

// სხვა დაბალი დონის რეალიზაცია (სხვა დეტალი)
class LocalDataService implements DataService {
  @override
  Future<List<String>> getData() async {
    // ადგილობრივი შენახვის მონაცემების მიღების ლოგიკა
    return ['Local Data 1', 'Local Data 2'];
  }
}

// მაღალი დონის მოდული, რომელიც დამოკიდებულია აბსტრაქციაზე, არა დეტალებზე
class DataManager {
  final DataService _dataService; // დამოკიდებულება აბსტრაქციაზე

  DataManager(this._dataService); // დამოკიდებულების ინექცია (ინვერსია)

  Future<List<String>> fetchData() {
    return _dataService.getData();
  }
}

// გამოყენება
void main() {
  final apiService = ApiDataService();
  final localService = LocalDataService();

  final apiManager = DataManager(apiService); // ApiDataService ინექცია
  final localManager = DataManager(localService); // LocalDataService ინექცია

  // ... გამოყენება apiManager ან localManager
}