¿Qué es DCI?

DCI (Data-Context-Interaction) es un patrón arquitectónico que se centra en cómo los objetos interactúan en un contexto específico para realizar una acción determinada. Está diseñado para mejorar la legibilidad y mantenibilidad del código, separando los datos (Data) del comportamiento en el contexto (Interaction), que actúa sobre ellos en una situación determinada (Context).

• Data (Datos): Representa el estado de los objetos. Esto puede ser clases o estructuras comunes que contienen datos.
• Context (Contexto): Describe una situación o escenario específico en el que ocurre la interacción de objetos. El contexto vincula a los participantes (objetos de datos) con roles.
• Interaction (Interacción): Define el comportamiento o lógica aplicada a los participantes del contexto. La interacción se realiza a través de roles que los participantes desempeñan en dicho contexto.

Ventajas de DCI:

• Mejor legibilidad: El código que describe la interacción está separado de la definición de datos, lo que lo hace más comprensible.
• Reducción de duplicación de código: El comportamiento específico de un escenario se encapsula, reduciendo la necesidad de duplicar lógica.
• Mayor flexibilidad: Es más fácil modificar o agregar nuevos escenarios de interacción sin alterar la definición de datos.
• Testabilidad: Los componentes separados (datos, contexto, interacciones) son más fáciles de probar de forma aislada.

Ejemplo (conceptual):

Imaginemos un escenario de "transferencia de dinero" entre dos cuentas bancarias.

• Data: Clase BankAccount con campos balance y accountNumber.
• Context: MoneyTransferContext que vincula dos objetos BankAccount con roles "Source" (remitente) y "Destination" (destinatario).
• Interaction: Lógica de transferencia de dinero: resta del saldo del remitente y suma al saldo del destinatario. Esta lógica se implementa a través de métodos en los roles "Source" y "Destination" dentro de MoneyTransferContext.

// Ejemplo de código conceptual (no una implementación completa de DCI)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

  // Métodos específicos de los datos
  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("Fondos insuficientes");
    }
  }
}

// Contexto y interacción (aquí mezclado por simplicidad)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interacción a través de roles (implícitamente aquí)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Transferencia exitosa de ${amount} de ${this.source.accountNumber} a ${this.destination.accountNumber}`);
    } catch (error: any) {
      console.error(`Error al transferir dinero: ${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); // Error por fondos insuficientes

En un DCI real, la interacción (lógica transfer) sería implementada en métodos "de rol" separados, que serían "inyectados" o "agregados" a los objetos BankAccount en el contexto MoneyTransferContext, sin modificar la clase BankAccount en sí. Esto se logra mediante diferentes técnicas dependiendo del lenguaje de programación.