Cos'è DCI?

DCI (Data-Context-Interaction) è un modello architetturale che si concentra su come gli oggetti interagiscono in un contesto specifico per eseguire un'azione determinata. È progettato per migliorare la leggibilità e la manutenibilità del codice, separando i dati (Data) dal comportamento nel contesto (Interaction), che agisce su di essi in una situazione specifica (Context).

• Data (Dati): Rappresenta lo stato degli oggetti. Può essere classi o strutture comuni che contengono dati.
• Context (Contesto): Descrive una situazione o scenario specifico in cui avviene l'interazione degli oggetti. Il contesto collega i partecipanti (oggetti di dati) con ruoli.
• Interaction (Interazione): Definisce il comportamento o la logica applicata ai partecipanti del contesto. L'interazione si realizza attraverso ruoli che i partecipanti interpretano in questo contesto.

Vantaggi di DCI:

• Migliore leggibilità: Il codice che descrive l'interazione è separato dalla definizione dei dati, rendendolo più comprensibile.
• Riduzione della duplicazione del codice: Il comportamento specifico di uno scenario è incapsulato, riducendo la necessità di duplicare la logica.
• Maggiore flessibilità: È più facile modificare o aggiungere nuovi scenari di interazione senza alterare la definizione dei dati.
• Testabilità: I componenti separati (dati, contesto, interazioni) sono più facili da testare in modo isolato.

Esempio (concettuale):

Immaginiamo uno scenario di "trasferimento di denaro" tra due conti bancari.

• Data: Classe BankAccount con campi balance e accountNumber.
• Contesto: MoneyTransferContext che collega due oggetti BankAccount con ruoli "Source" (mittente) e "Destination" (destinatario).
• Interazione: La logica di trasferimento di denaro: sottrazione dal saldo del mittente e aggiunta al saldo del destinatario. Questa logica viene implementata tramite metodi nei ruoli "Source" e "Destination" all'interno di MoneyTransferContext.

// Esempio di codice concettuale (non una piena implementazione DCI)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Metodi specifici per i dati
  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("Fondi insufficienti");
    }
  }
}

// Contesto e interazione (qui mescolati per semplicità)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interazione tramite ruoli (implicitamente qui)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Trasferimento di ${amount} da ${this.source.accountNumber} a ${this.destination.accountNumber} riuscito`);
    } catch (error: any) {
      console.error(`Errore nel trasferimento di denaro: ${error.message}`);
    }
  }
}

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

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Errore per fondi insufficienti

In un vero DCI, l'interazione (la logica transfer) sarebbe implementata in metodi "ruolo" separati, che vengono "iniettati" o "aggiunti" agli oggetti BankAccount nel contesto MoneyTransferContext, senza modificare la classe BankAccount stessa. Questo si ottiene tramite diverse tecniche a seconda del linguaggio di programmazione.