Wat is DCI?

DCI (Data-Context-Interaction) is een architectuurpatroon dat zich richt op hoe objecten in een specifieke context met elkaar omgaan om een bepaalde actie uit te voeren. Het is bedoeld om de leesbaarheid en onderhoudbaarheid van de code te verbeteren door gegevens (Data) te scheiden van gedrag in de context (Interaction), dat op hen in een bepaalde situatie (Context) inwerkt.

• Data (Gegevens): Vertegenwoordigt de toestand van de objecten. Dit kunnen gewone klassen of structuren zijn die gegevens bevatten.
• Context (Context): Beschrijft een specifieke situatie of scenario waarin de interactie van objecten plaatsvindt. De context verbindt de deelnemers (gegevensobjecten) met rollen.
• Interaction (Interactie): Bepaalt het gedrag of de logica die op de deelnemers van de context wordt toegepast. De interactie wordt gerealiseerd via rollen die de deelnemers in deze context spelen.

Voordelen van DCI:

• Betere leesbaarheid: De code die de interactie beschrijft, is gescheiden van de definitie van gegevens, waardoor deze beter te begrijpen is.
• Vermindering van code duplicatie: Het gedrag dat specifiek is voor een scenario wordt ingekapseld, waardoor de noodzaak om logica te dupliceren afneemt.
• Grotere flexibiliteit: Het is gemakkelijker om nieuwe interactiescenario's te wijzigen of toe te voegen zonder de gegevensdefinitie te veranderen.
• Testbaarheid: Gescheiden componenten (gegevens, context, interacties) zijn gemakkelijker te testen in isolatie.

Voorbeeld (conceptueel):

Stel je een scenario voor van "geldovermaking" tussen twee bankrekeningen.

• Data: Klasse BankAccount met velden balance en accountNumber.
• Context: MoneyTransferContext die twee BankAccount-objecten verbindt met de rollen "Source" (afzender) en "Destination" (ontvanger).
• Interactie: De logica van geldovermaking: aftrekken van het saldo van de zender en toevoegen aan het saldo van de ontvanger. Deze logica wordt geïmplementeerd via methoden in de rollen "Source" en "Destination" binnen MoneyTransferContext.

// Conceptueel codevoorbeeld (geen volledige DCI-implementatie)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Methoden die specifiek zijn voor gegevens
  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("Onvoldoende saldo");
    }
  }
}

// Context en interactie (hier gemengd voor eenvoud)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interactie via rollen (niet expliciet hier)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Succesvol overgemaakt ${amount} van ${this.source.accountNumber} naar ${this.destination.accountNumber}`);
    } catch (error: any) {
      console.error(`Fout bij geldovermaking: ${error.message}`);
    }
  }
}

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

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Fout door onvoldoende saldo

In een echte DCI zou de interactie (de transfer-logica) worden geïmplementeerd in aparte "rol"-methoden, die worden " geïnjecteerd" of "toegevoegd" aan de BankAccount-objecten in de MoneyTransferContext, zonder de BankAccount-klasse zelf te wijzigen. Dit wordt bereikt door verschillende technieken afhankelijk van de programmeertaal.