Conheça o framework que une Injeção de Dependência, Minimal APIs e um ORM Code-First sem sair da linguagem que você domina.
Introdução
Há anos, uma parte significativa da comunidade Delphi olha para o ecossistema .NET — especificamente para o ASP.NET Core — com um certo nível de admiração técnica. A facilidade de escrever APIs RESTful, a injeção de dependência nativa e a limpeza do código assíncrono são padrões que todos desejamos em nossos backends.
Muitos desenvolvedores acabam migrando seus backends para C# apenas para acessar essa arquitetura, mantendo o Delphi apenas no legado ou no front-end desktop. Mas e se fosse possível ter essa mesma experiência de desenvolvimento — Fluent APIs, Middlewares, Async/Await real — dentro do Delphi, compilando para código nativo e performático?
É exatamente essa a proposta do Dext, um novo framework open-source criado por Cesar Romero, MVP Embarcadero, que promete modernizar a stack de desenvolvimento Delphi. Neste artigo, vamos explorar o que é o Dext, como ele funciona e por que ele merece sua atenção.
Vamos neste artigo conhecer melhor esse projeto de código aberto, suas vantagens e facilidades.
O que é o Dext?
O Dext define-se como um ecossistema completo para desenvolvimento moderno. Ele não é apenas um componente para subir um servidor HTTP; é uma suíte inspirada fortemente na filosofia do .NET Core, mas adaptada para a realidade do Object Pascal.
O projeto se baseia em três pilares fundamentais:
- Dext.Web: Um framework HTTP leve para APIs REST (suporte a Minimal APIs e Controllers).
- Dext.Entity: Um ORM focado em produtividade (Code-First e Fluent Queries).
- Dext.Core: A infraestrutura base, provendo Injeção de Dependência (DI), Logging e Primitivos Assíncronos.
Minimal APIs no Delphi: Adeus ao Boilerplate
Uma das maiores tendências atuais é a criação de “Minimal APIs” — rotas declaradas de forma concisa, sem a necessidade de criar classes de Controller verborrágicas para endpoints simples.
Veja como se escreve um “Hello World” com parâmetro no Dext. Note a ausência de DataModules ou componentes visuais arrastados:
uses
Dext.Core.WebApplication,
Dext.Http.Results;
begin
var App := TDextApplication.Create;
var Builder := App.GetApplicationBuilder;
// Rota GET simples com captura de parâmetro na URL
Builder.MapGetR<Integer, IResult>('/users/{id}',
function(Id: Integer): IResult
begin
// Retorno JSON automático
Result := Results.Json(Format('{"userId": %d, "status": "active"}', [Id]));
end);
App.Run(8080);
end.
O framework faz o Smart Binding: ele entende que {id} na rota é um Inteiro e passa para a função anônima automaticamente. Se você declarar um record ou class como parâmetro, ele tentará deserializar o corpo do JSON automaticamente.
Injeção de Dependência (DI) como Cidadã de Primeira Classe
No desenvolvimento moderno, o acoplamento forte é o inimigo. O Dext traz um container de Injeção de Dependência (IoC) robusto. Você registra suas interfaces e implementações na inicialização, e o framework resolve a árvore de dependências para você.
// 1. Registro dos serviços (Singleton, Scoped ou Transient)
App.Services.AddSingleton<IEmailService, TEmailService>;
App.Services.AddScoped<IUserRepository, TUserRepository>;
// 2. Uso na rota: O Dext injeta o 'EmailService' automaticamente
App.MapPostR<TUserDto, IEmailService, IResult>('/register',
function(Dto: TUserDto; EmailService: IEmailService): IResult
begin
EmailService.SendWelcome(Dto.Email);
Result := Results.Created('/login', 'Usuário registrado');
end);
Isso elimina a necessidade de criar instâncias manualmente (TClasse.Create) espalhadas pelo código, facilitando drasticamente os testes unitários.
ORM Code-First e Fluent API
Para quem está cansado de SQL strings mágicas ou de componentes TDataset pesados, o Dext.Entity oferece uma abordagem limpa. Ele suporta bancos como SQL Server, PostgreSQL, Firebird, MySQL e Oracle.
A sintaxe é fluente e fortemente tipada:
// Exemplo de consulta complexa sem escrever SQL manual
var Orders := DbContext.Orders
.Where((O.Status = TOrderStatus.Paid) and (O.Total > 1000)) // Filtro tipado
.Include('Customer') // Eager Loading (JOIN automático)
.Include('Items')
.OrderByDescending('Date')
.Take(50)
.ToList;
Além disso, ele suporta Migrations. Você define suas tabelas como classes Delphi, e o framework gera/atualiza o banco de dados para você via CLI, mantendo o versionamento do schema.
Async/Await e Tasks
O Delphi possui a TTask, mas o gerenciamento de threads ainda pode ser complexo. O Dext introduz uma sintaxe de Promises encadeadas, permitindo código assíncrono que não trava a thread principal (ou a thread do servidor web) e trata exceções de forma centralizada.
TAsyncTask.Run<TRelatorio>(
function: TRelatorio
begin
// Executa em thread separada
Result := ServicoRelatorio.GerarPesado();
end)
.OnComplete(
procedure(Relatorio: TRelatorio)
begin
// Volta contexto automaticamente (ex: logar sucesso)
end)
.Start;
Considerações Técnicas e Roadmap
É importante ressaltar que o projeto está em desenvolvimento ativo (v1.0). O autor, Cesar Romero, deixa claro que a API pública pode sofrer alterações (breaking changes) até a estabilização da versão final.
Atualmente, ele utiliza Indy como camada de transporte (o que garante compatibilidade), mas com abstrações que permitirão a troca futura por sockets mais performáticos sem quebrar a aplicação do usuário. Recomenda-se o uso do FastMM5 para gerenciamento de memória em projetos que utilizem o framework.
Conclusão
O Dext é uma lufada de ar fresco para o desenvolvedor Delphi. Ele prova que é possível escrever código limpo, testável e moderno sem abandonar a linguagem. Para empresas que possuem grande know-how em Object Pascal, mas precisam modernizar suas APIs e arquitetura, o Dext é um projeto que merece ser acompanhado de perto (e testado).
Onde encontrar: O projeto é Open Source (Licença Apache 2.0) e está disponível no GitHub: https://github.com/cesarliws/dext
0 comentário(s)