O que é DCI?

O DCI (Data-Context-Interaction) é um padrão arquitetónico que se concentra em como os objetos interagem num contexto específico para realizar uma ação definida. Destina-se a melhorar a legibilidade e a manutenção do código, separando os dados (Data) do comportamento no contexto (Interaction), que atua sobre eles numa situação específica (Context).

• Data (Dados): Representa o estado dos objetos. Pode ser classes ou estruturas comuns que contêm dados.
• Context (Contexto): Descreve uma situação ou cenário específico em que ocorre a interação de objetos. O contexto liga os participantes (objetos de dados) aos papéis.
• Interaction (Interação): Define o comportamento ou lógica aplicada aos participantes do contexto. A interação é realizada através de papéis que os participantes desempenham neste contexto.

Vantagens do DCI:

• Melhor legibilidade: O código que descreve a interação está separado da definição de dados, tornando-o mais compreensível.
• Redução de duplicação de código: O comportamento específico de um cenário é encapsulado, reduzindo a necessidade de duplicar lógica.
• Maior flexibilidade: É mais fácil modificar ou adicionar novos cenários de interação sem alterar a definição de dados.
• Testabilidade: Os componentes separados (dados, contexto, interações) são mais fáceis de testar de forma isolada.

Exemplo (conceitual):

Imaginemos um cenário de "transferência de dinheiro" entre duas contas bancárias.

• Data: Classe BankAccount com campos balance e accountNumber.
• Contexto: MoneyTransferContext que liga dois objetos BankAccount com papéis "Source" (remetente) e "Destination" (destinatário).
• Interação: A lógica de transferência de dinheiro: subtrair do saldo do remetente e adicionar ao saldo do destinatário. Essa lógica é implementada através de métodos nos papéis "Source" e "Destination" dentro de MoneyTransferContext.

// Exemplo de código conceptual (não uma implementação completa de DCI)
class BankAccount {
  constructor(public balance: number, public accountNumber: string) {}

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

// Contexto e interação (aqui misturado por simplicidade)
class MoneyTransferContext {
  constructor(private source: BankAccount, private destination: BankAccount) {}

  transfer(amount: number): void {
    try {
      // Interação através de papéis (não explicitamente aqui)
      this.source.withdraw(amount);
      this.destination.deposit(amount);
      console.log(`Transferência bem-sucedida de ${amount} de ${this.source.accountNumber} para ${this.destination.accountNumber}`);
    } catch (error: any) {
      console.error(`Falha na transferência de dinheiro: ${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); // Erro devido a fundos insuficientes

Num DCI real, a interação (lógica transfer) seria implementada em métodos "de papel" separados, que seriam "injecções" ou "adicionados" aos objetos BankAccount no contexto MoneyTransferContext, sem alterar a própria classe BankAccount. Isto é conseguido através de várias técnicas, dependendo da linguagem de programação.