Was ist DCI?

DCI (Data-Context-Interaction) ist ein architektonisches Muster, das sich darauf konzentriert, wie Objekte in einem bestimmten Kontext interagieren, um eine bestimmte Aktion auszuführen. Es soll die Lesbarkeit und Wartbarkeit des Codes verbessern, indem Daten (Data) vom Verhalten im Kontext (Interaction) getrennt werden, das in einer bestimmten Situation (Context) auf sie wirkt.

• Data (Daten): Repräsentiert den Zustand der Objekte. Dies können gewöhnliche Klassen oder Strukturen sein, die Daten enthalten.
• Context (Kontext): Beschreibt eine konkrete Situation oder ein Szenario, in dem die Interaktion der Objekte stattfindet. Der Kontext verbindet die Teilnehmer (Datenobjekte) mit Rollen.
• Interaction (Interaktion): Definiert das Verhalten oder die Logik, die auf die Teilnehmer des Kontexts angewendet wird. Die Interaktion wird durch Rollen realisiert, die die Teilnehmer in diesem Kontext spielen.

Vorteile von DCI:

• Verbesserte Lesbarkeit: Der Code, der die Interaktion beschreibt, ist vom Daten-Definitionscode getrennt, was ihn verständlicher macht.
• Reduzierung von Code-Duplikation: Das spezifische Verhalten für ein Szenario wird kapsuliert, was die Notwendigkeit reduziert, Logik zu duplizieren.
• Erhöhte Flexibilität: Es ist einfacher, neue Interaktionsszenarien zu ändern oder hinzuzufügen, ohne die Daten-Definition zu verändern.
• Testbarkeit: Getrennte Komponenten (Daten, Kontext, Interaktionen) sind leichter isoliert zu testen.

Beispiel (konzeptuell):

Stellen wir uns ein Szenario "Geldüberweisung" zwischen zwei Bankkonten vor.

• Data: Klasse BankAccount mit den Feldern balance und accountNumber.
• Context: MoneyTransferContext, das zwei BankAccount-Objekte mit den Rollen "Source" (Absender) und "Destination" (Empfänger) verbindet.
• Interaction: Die Logik der Geldüberweisung: Abzug vom Saldo des Absenders und Hinzufügen zum Saldo des Empfängers. Diese Logik wird durch Methoden in den Rollen "Source" und "Destination" innerhalb von MoneyTransferContext umgesetzt.

// Konzeptuelles Codebeispiel (keine vollständige DCI-Implementierung)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Methoden, die spezifisch für Daten sind
  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("Unzureichende Mittel");
    }
  }
}

// Kontext und Interaktion (hier vereinfacht)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interaktion durch Rollen (nicht explizit hier)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Erfolgreich ${amount} von ${this.source.accountNumber} nach ${this.destination.accountNumber} übertragen`);
    } catch (error: any) {
      console.error(`Fehler beim Geldtransfer: ${error.message}`);
    }
  }
}

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

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Fehler wegen unzureichender Mittel

In einem echten DCI würde die Interaktion (die transfer-Logik) in separaten "Rollen"-Methoden implementiert, die in den BankAccount-Objekten im MoneyTransferContext-Kontext "injiziert" oder "hinzugefügt" werden, ohne die BankAccount-Klasse selbst zu verändern. Dies wird durch verschiedene Techniken erreicht, abhängig von der Programmiersprache.