Mi az a DCI?

A DCI (Data-Context-Interaction) egy architekturális mintázat, amely arra összpontosít, hogyan lépnek kölcsönhatásba az objektumok egy adott kontextusban, hogy végrehajtsanak egy meghatározott műveletet. Célja a kód olvashatóságának és karbantarthatóságának javítása, az adatok (Data) és a viselkedés (Interaction) elkülönítésével a kontextusban (Context), amely azokon belül működik.

• Data (Adatok): Az objektumok állapotát képviseli. Lehetnek egyszerű osztályok vagy struktúrák, amelyek adatokat tartalmaznak.
• Context (Környezet): Leírja az adott helyzetet vagy szcenáriót, amelyben az objektumok kölcsönhatásba lépnek. A környezet összekapcsolja a résztvevőket (adatobjektumokat) szerepekkel.
• Interaction (Kölcsönhatás): Meghatározza a viselkedést vagy a logikát, amely alkalmazva van a környezet résztvevőire. A kölcsönhatás a szerepek révén valósul meg, amelyeket a résztvevők játszanak ebben a kontextusban.

A DCI előnyei:

• Javított olvashatóság: A kölcsönhatást leíró kód elkülönül az adatok meghatározásától, így könnyebben érthető.
• Kódismétlés csökkentése: A konkrét szcenárióhoz tartozó viselkedés inkapszulálva van, csökkentve a logika ismétlését.
• Nagyobb rugalmasság: Könnyebb módosítani vagy új kölcsönhatási szcenáriókat hozzáadni anélkül, hogy az adatok meghatározását érintenénk.
• Tesztelhetőség: Az egyes komponensek (adatok, környezet, kölcsönhatások) izoláltan könnyebben tesztelhetők.

Példa (koncepcionális):

Képzeljük el a "pénz átutalása" szcenáriót két banki számla között.

• Data: A BankAccount osztály balance és accountNumber mezőkkel.
• Context: MoneyTransferContext, amely két BankAccount objektumot köt össze "Source" (küldő) és "Destination" (fogadó) szerepekkel.
• Interaction: A pénz átutalás logikája: a küldő egyenlegéből levonás és a fogadó egyenlegéhez hozzáadás. Ez a logika a MoneyTransferContext belsejében a "Source" és "Destination" szerepek metódusain keresztül valósul meg.

// Koncepcionális kód példa (nem teljes DCI megvalósítás)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Adatokhoz kapcsolódó metódusok
  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("Elégtelen fedezet");
    }
  }
}

// Környezet és kölcsönhatás (egyszerűsített példában keverednek)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Kölcsönhatás szerepek révén (itt nem nyilvánvaló)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Sikeresen átutalt ${amount} a ${this.source.accountNumber} -ról a ${this.destination.accountNumber} -ra`);
    } catch (error: any) {
      console.error(`Az átutalás nem sikerült: ${error.message}`);
    }
  }
}

// Használat
const account1 = new BankAccount(1000, "123");
const account2 = new BankAccount(500, "456");

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Hiba az elégtelen fedezet miatt

A valódi DCI-ben a kölcsönhatás (pl. transfer logika) külön "szerep" metódusokban valósulna meg, amelyeket "injektálnának" vagy "hozzáadnának" a BankAccount objektumokhoz a MoneyTransferContext kontextusában, anélkül, hogy módosítanák a BankAccount osztályt. Ez különböző technikákkal érhető el a programozási nyelvtől függően.