რა არის DCI?

DCI (მონაცემები-კონტექსტი-ინტერაქცია) არის არქიტექტურული ნიმუში, რომელიც ყურადღებას აქცევს იმაზე, თუ როგორ ურთიერთქმედებენ ობიექტები კონკრეტულ კონტექსტში, რათა შეასრულონ გარკვეული მოქმედება. მისი მიზანია კოდის წაკითხულობისა და შენარჩუნების გაუმჯობესება, მონაცემების (Data) გამოყოფით კონტექსტში (Interaction), რომელიც მოქმედებს მათზე გარკვეულ სიტუაციაში (Context).

• მონაცემები (Data): წარმოადგენს ობიექტების მდგომარეობას. ეს შეიძლება იყოს ჩვეულებრივი კლასები ან სტრუქტურები, რომლებიც შეიცავს მონაცემებს.
• კონტექსტი (Context): აღწერს კონკრეტულ სიტუაციას ან სცენარს, სადაც ხდება ობიექტების ურთიერთქმედება. კონტექსტი აკავშირებს მონაწილეებს (მონაცემთა ობიექტებს) როლებთან.
• ინტერაქცია (Interaction): განსაზღვრავს ქცევას ან ლოგიკას, რომელიც გამოიყენება კონტექსტის მონაწილეებზე. ურთიერთქმედება რეალიზდება როლების მეშვეობით, რომლებიც მონაწილეები თამაშობენ ამ კონტექსტში.

DCI-ს უპირატესობები:

• მოკლე წაკითხულობა: ურთიერთქმედების აღწერა კოდში გამოყოფილია მონაცემების განსაზღვრიდან, რაც მას უფრო გასაგებს ხდის.
• კოდების დუბლირების შემცირება: სპეციფიკური სცენარის ქცევა ინკაპსულირებულია, რაც ამცირებს ლოგიკის დუბლირების საჭიროებას.
• მაღალი მოქნილობა: უფრო ადვილია ურთიერთქმედების ახალი სცენარების დამატება ან შეცვლა, მონაცემების განსაზღვრების შეცვლის გარეშე.
• ტესტირებადობა: ცალკეული კომპონენტები (მონაცემები, კონტექსტი, ურთიერთქმედებები) უფრო მარტივად ტესტირებადია იზოლირებულად.

პრაქტიკული მაგალითი:

გავიგოთ სცენარი "თანხის გადარიცხვა" ორ ბანკის ანგარიშს შორის.

• მონაცემები: კლასი BankAccount with fields balance and accountNumber.
• კონტექსტი: MoneyTransferContext რომელიც აკავშირებს ორ BankAccount ობიექტს როლებით "წყარო" (გადამცემი) და "მიღმა" (მიღებელი).
• ინტერაქცია: თანხის გადარიცხვის ლოგიკა: გამოთლება გადამცემის ბალანსიდან და დამატება მიღების ბალანსზე. ეს ლოგიკა რეალიზდება როლების მეთოდების მეშვეობით MoneyTransferContext-ში.

// მაგალითი კონცეპტუალური კოდის (სრული DCI-ის რეალიზაცია არა)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // მონაცემებზე სპეციფიკური მეთოდები
  getBalance(): number {
    return this.balance;
  }

  deposit(amount: number): void {
    this.balance += amount;
  }

  withdraw(amount: number): void {
    if (this.balance >= amount) {
      this.balance -= amount;
    } else {
      throw new Error("ნაკლებადია ფულადი სახსრები");
    }
  }
}

// კონტექსტი და ურთიერთქმედება (მარტივობისთვის შერეულია)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // ურთიერთქმედება როლების მეშვეობით
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`წარმატებით გადარიცხული ${amount} ${this.source.accountNumber}-დან ${this.destination.accountNumber}-მდე`);
    } catch (error: any) {
      console.error(`გადარიცხვის ვერ მოხერხდა: ${error.message}`);
    }
  }
}

// გამოყენება
const account1 = new BankAccount(1000, "123");
const account2 = new BankAccount(500, "456");

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // შეცდომა ნაკლებად ფულადი სახსრების გამო

რეალურ DCI-ში ურთიერთქმედება (ლოგიკა transfer) იქნებოდა რეალიზებული ცალკეულ "როლურ" მეთოდებში, რომლებიც "ინექცირდებიან" ან "დამატებით" ხდებიან BankAccount ობიექტებზე MoneyTransferContext კონტექსტში, ისე რომ არ იცვლება BankAccount კლასი. ეს მიღწეულია სხვადასხვა მეთოდებით, დამოკიდებული პროგრამირების ენაზე.