Ce este DCI?

DCI (Data-Context-Interaction) este un model arhitectural care se concentrează pe modul în care obiectele interacționează într-un anumit context pentru a realiza o acțiune specifică. Scopul său este de a îmbunătăți lizibilitatea și întreținerea codului, separând datele (Data) de comportament în context (Interaction), care acționează asupra lor într-o situație dată (Context).

• Data (Date): Reprezintă starea obiectelor. Acestea pot fi clase obișnuite sau structuri care conțin date.
• Context (Context): Descrie o situație sau scenariu specific în care are loc interacțiunea obiectelor. Contextul leagă participanții (obiecte de date) cu roluri.
• Interaction (Interacțiune): Definește comportamentul sau logica aplicată participanților din context. Interacțiunea se realizează prin roluri pe care participanții le joacă în acest context.

Avantajele DCI:

• O mai bună lizibilitate: Codul care descrie interacțiunea este separat de definirea datelor, ceea ce îl face mai ușor de înțeles.
• Reducerea duplicării codului: Comportamentul specific unui scenariu este încapsulat, reducând necesitatea de a duplica logica.
• Flexibilitate crescută: Este mai ușor să modifici sau să adaugi noi scenarii de interacțiune fără a schimba definiția datelor.
• Testabilitate: Componentele separate (date, context, interacțiuni) sunt mai ușor de testat izolat.

Exemplu (conceptual):

Imaginați-vă un scenariu de "transfer de bani" între două conturi bancare.

• Data: Clasa BankAccount cu câmpurile balance și accountNumber.
• Context: MoneyTransferContext care leagă două obiecte BankAccount cu rolurile "Source" (expeditor) și "Destination" (destinatar).
• Interacțiune: Logica transferului de bani: scăderea din soldul expeditorului și adăugarea la soldul destinatarului. Această logică este implementată prin metode în rolurile "Source" și "Destination" în cadrul MoneyTransferContext.

// Exemplu de cod conceptual (nu o implementare completă DCI)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Metode specifice datelor
  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("Fonduri insuficiente");
    }
  }
}

// Context și interacțiune (aici combinate pentru simplitate)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interacțiune prin roluri (implicit aici)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Transfer cu succes de ${amount} de la ${this.source.accountNumber} la ${this.destination.accountNumber}`);
    } catch (error: any) {
      console.error(`Eșec la transferul de bani: ${error.message}`);
    }
  }
}

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

const transferContext = new MoneyTransferContext(account1, account2);
transferContext.transfer(200);
transferContext.transfer(1500); // Eroare din cauza fondurilor insuficiente

Într-un DCI real, interacțiunea (logica transfer) ar fi implementată în metode "de rol" separate, care sunt "injectate" sau "adăugate" obiectelor BankAccount în cadrul MoneyTransferContext, fără a modifica clasa BankAccount în sine. Acest lucru se realizează prin diferite tehnici, în funcție de limbajul de programare.