Qu'est-ce que le DCI?

DCI (Data-Context-Interaction) est un modèle architectural qui se concentre sur la façon dont les objets interagissent dans un contexte spécifique pour effectuer une action déterminée. Il vise à améliorer la lisibilité et la maintenabilité du code, en séparant les données (Data) du comportement dans le contexte (Interaction), qui agit sur elles dans une situation donnée (Context).

• Data (Données): Représente l'état des objets. Cela peut être des classes ou des structures ordinaires contenant des données.
• Context (Contexte): Décrit une situation ou un scénario spécifique dans lequel l'interaction des objets se produit. Le contexte relie les participants (objets de données) avec des rôles.
• Interaction (Interaction): Définit le comportement ou la logique appliquée aux participants du contexte. L'interaction est réalisée à travers des rôles que jouent les participants dans ce contexte.

Avantages de DCI:

• Meilleure lisibilité: Le code décrivant l'interaction est séparé de la définition des données, ce qui le rend plus compréhensible.
• Réduction de la duplication de code: Le comportement spécifique à un scénario est encapsulé, ce qui réduit la nécessité de dupliquer la logique.
• Plus grande flexibilité: Il est plus facile de modifier ou d'ajouter de nouveaux scénarios d'interaction sans changer la définition des données.
• Testabilité: Les composants séparés (données, contexte, interactions) sont plus faciles à tester isolément.

Exemple (conceptuel):

Imaginons un scénario de "transfert d'argent" entre deux comptes bancaires.

• Data: Classe BankAccount avec les champs balance et accountNumber.
• Contexte: MoneyTransferContext qui relie deux objets BankAccount avec les rôles "Source" (expéditeur) et "Destination" (destinataire).
• Interaction: La logique de transfert d'argent : déduction du solde de l'expéditeur et ajout au solde du destinataire. Cette logique est implémentée via des méthodes dans les rôles "Source" et "Destination" au sein de MoneyTransferContext.

// Exemple de code conceptuel (pas une implémentation complète de DCI)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Méthodes spécifiques aux données
  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("Fonds insuffisants");
    }
  }
}

// Contexte et interaction (ici mélangés pour la simplicité)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interaction via rôles (implicitement ici)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Transfert réussi de ${amount} de ${this.source.accountNumber} à ${this.destination.accountNumber}`);
    } catch (error: any) {
      console.error(`Échec du transfert d'argent : ${error.message}`);
    }
  }
}

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

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Erreur due à fonds insuffisants

Dans un DCI réel, l'interaction (logique transfer) serait implémentée dans des méthodes "de rôle" séparées, qui seraient "injectées" ou "ajoutées" aux objets BankAccount dans le contexte MoneyTransferContext, sans modifier la classe BankAccount elle-même. Cela est réalisé par différentes techniques selon le langage de programmation.