Mediator4D: Delphi com Flexibilidade de Linguagens Dinâmicas

Introdução

Sim, o Delphi também pensa. E talvez mais do que muita gente imagina.

Se você acha que Delphi é apenas Button1.Click e ShowMessage('Olá'), prepare-se para expandir seus horizontes. Neste artigo, vamos explorar um mecanismo chamado Mediator4D: uma arquitetura de invocação dinâmica de métodos que se apoia em RTTI (Run-Time Type Information), TValue e padrões como Command, Mediator e Fluent Interface. Tudo isso usando Delphi puro.

O Mediator4D é uma ponte entre o Delphi clássico e uma abordagem moderna, flexível, e poderosa — algo que você esperaria encontrar em C#, TypeScript ou Python. E acredite: ele entrega isso.

O que é o Mediator4D?

O Mediator4D é um mecanismo de mediação de métodos em Delphi que permite:

• Registrar funções com identificadores
• Invocá-las em tempo de execução com argumentos genéricos (TValue)
• Utilizar uma API fluente para facilitar a chamada
• Reduzir o acoplamento entre módulos ou camadas
• Encapsular lógica como "comandos invocáveis"

Esse sistema cria um centro de execução desacoplado, permitindo que o código não precise mais saber quem vai executar uma ação, apenas o que deve ser feito.

Por que isso é relevante?

Embora o Delphi seja uma linguagem fortemente tipada e estática, ele possui um poderoso sistema de RTTI que poucos exploram a fundo. O Mediator4D leva esse recurso ao limite, permitindo execução genérica de métodos, desacoplada do tipo e do contexto.

Com isso, você pode:

• Criar comandos genéricos com nomes amigáveis
• Integrar facilmente configurações externas (ex: JSON com nome da ação e argumentos)
• Construir mini-DSLs ou motores de script internos
• Centralizar lógicas comuns em frameworks e bibliotecas
• Facilitar prototipagem e testes rápidos

Comparativo com outras bibliotecas Delphi

Embora existam bibliotecas como o Spring4D e o DSharp, que trabalham com containers, inversão de dependência e RTTI para data binding, nenhuma delas oferece um mecanismo de invocação genérica de funções registradas por identificador com suporte fluente e argumentos dinâmicos como o Mediator4D.

O Mediator4D não é um service locator, não é um container, e não é um IOC. Ele é um executor. Um dispatcher.

Na prática, ele permite que você crie comandos dinamicamente, os encadeie, injete argumentos, e chame métodos sem saber nada sobre suas assinaturas em tempo de compilação.

Estrutura do Mediator4D

O sistema está dividido em cinco unidades principais:

API Fluente: Como usar

Um exemplo simples de invocação:

LResultado := TMediator
  .CreateCallTo('FuncaoSomar')
  .&WithArgument(42)
  .&WithArgument(58)
  .&CallAsFunction;

ShowMessage(LResultado.ToString); // Exibe 100

A função FuncaoSomar foi previamente registrada com dois inteiros como argumento. A invocação fluente esconde os detalhes técnicos e mostra apenas a intenção: invocar um método com argumentos.

Casos de Uso

• Automatização e DSLs internas: você pode definir arquivos JSON ou XML com comandos e executar dinamicamente no Delphi.
• Testes unitários e mocks: substitui métodos reais por métodos de teste sem alterar o código cliente.
• Plugins e integração de módulos: novos módulos podem se registrar como comandos executáveis.
• Interfaces administrativas e ferramentas de debugging.

Limitações e Cuidados

• Requer conhecimento de RTTI, TValue e seus perigos
• Pode afetar performance se usado em alta escala sem cache
• Reduz segurança de tipo em tempo de compilação
• Requer boas práticas de nomeação e convenções para evitar colisões

Mas como qualquer ferramenta poderosa, deve ser usada com discernimento.

🤔 Pergunta Comum:

“Por que usar o Mediator4D se eu posso simplesmente chamar um método direto?”

Essa pergunta é justa — e muito importante.

Sim, se você souber exatamente qual função vai chamar, e os parâmetros, e a unidade onde ela está, e o tipo esperado, então chamar o método direto é sempre mais simples.

Mas agora imagine outro cenário:

📦 Cenário: Sistema lê JSON e cria uma tabela em tempo real

Você recebe um arquivo externo com a seguinte definição:

{
  "nome": "Clientes",
  "campos": [
    { "nome": "ID", "tipo": "Integer" },
    { "nome": "Nome", "tipo": "String", "tamanho": 100 },
    { "nome": "Nascimento", "tipo": "Date" },
    { "nome": "Ativo", "tipo": "Boolean" }
  ]
}

Essa informação está fora do seu código. Mas com o Mediator4D, basta registrar uma função CriarTabela e chamá-la assim:

TMediator.CreateCallTo('CriarTabela')
  .&WithArgument(LConteudoDoJson)
  .&CallAsFunction;

Resultado: uma TFDMemTable criada em tempo de execução, com campos dinâmicos definidos por um arquivo. Nada de if, nada de case, nada de recompilar. Basta mudar o JSON.

Isso não é apenas diferente — é um outro paradigma de desenvolvimento.

Considerações Finais

O Mediator4D mostra que o Delphi pode ser muito mais dinâmico do que se imagina. Ele rompe com a ideia de que Delphi é apenas uma linguagem para apps RAD clássicos e mostra que é possível criar arquiteturas modernas, desacopladas, e inteligentes.

Se você trabalha com Delphi e quer explorar novas formas de escrever código, o Mediator4D é um excelente começo. E se você vier de outras linguagens, prepare-se para rever seus conceitos.

Na segunda parte, vamos ver o Mediator4D em ação com exemplos didáticos.

Continua...