No Delphi, Class Helpers são um recurso útil para adicionar novos métodos a uma classe já existente sem precisar modificá-la diretamente. Essa funcionalidade é especialmente útil quando estamos trabalhando com classes de bibliotecas fechadas ou quando queremos estender funcionalidades sem alterar o código original.
Com um Class Helper, podemos definir métodos adicionais para uma classe sem criar herança. Diferente da herança tradicional, que permite sobrescrever e modificar comportamentos, os helpers atuam como uma extensão temporária da classe original. Eles são amplamente utilizados para organizar código e tornar a programação mais flexível e legível.
No entanto, é importante usá-los com cuidado, pois algumas limitações podem impactar sua utilização. Neste artigo, exploraremos como funcionam os Class Helpers, suas vantagens e desvantagens, e como aplicá-los de forma eficiente no Delphi.
O que é um Class Helper?
No Delphi, um Class Helper é uma maneira de estender uma classe existente sem modificá-la diretamente. Diferente da herança tradicional, onde criamos uma nova classe derivada da original, um Class Helper permite adicionar métodos à classe sem precisar alterar seu código-fonte.
Essa técnica é útil quando trabalhamos com classes de bibliotecas fechadas (como TStringList, TDateTime, TButton, etc.), permitindo criar métodos adicionais sem tocar na implementação original.
Os Class Helpers funcionam como uma “camada temporária” sobre a classe, fornecendo métodos auxiliares que podem ser usados como se fossem parte da própria classe. Porém, eles não permitem sobrescrever métodos existentes nem adicionar propriedades ou variáveis de instância.
Como funciona um Class Helper?
Os Class Helpers funcionam como uma “extensão” de uma classe existente. Ao definir um helper para uma determinada classe, o Delphi passa a reconhecer os métodos adicionais como se fizessem parte dela.
A sintaxe básica de um Class Helper é a seguinte:
|
1 2 3 4 5 6 |
type TMinhaClasseHelper = class helper for TClasseOriginal function NovoMetodo: string; end; |
TMinhaClasseHelper: Nome do helper que estamos criando.class helper for TClasseOriginal: Indica que este helper está estendendo a classeTClasseOriginal.function NovoMetodo: string;: Método que estamos adicionando à classe.
Agora, vamos aplicar isso a um exemplo prático com TStringList.
Exemplo prático: Criando um Class Helper para TStringList
Suponha que queremos adicionar um método à classe TStringList para obter o último item da lista. Sem um helper, precisaríamos escrever essa lógica manualmente sempre que precisássemos. Com um Class Helper, podemos encapsular esse comportamento de forma reutilizável:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
type TStringListHelper = class helper for TStringList function GetUltimoItem: string; end; implementation function TStringListHelper.GetUltimoItem: string; begin if Count > 0 then Result := Strings[Count - 1] else Result := ''; end; |
Agora, podemos usar esse novo método como se fosse parte do TStringList:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
var Lista: TStringList; begin Lista := TStringList.Create; try Lista.Add('Primeiro'); Lista.Add('Segundo'); Lista.Add('Terceiro'); ShowMessage(Lista.GetUltimoItem); // Exibe "Terceiro" finally Lista.Free; end; end; |
Principais Características de um Class Helper
- Extensão sem Herança – Você pode adicionar métodos a uma classe sem criar uma subclasse.
- Não altera a classe original – A implementação original permanece intacta.
- Métodos apenas, sem novas propriedades ou variáveis – Diferente da herança, helpers não podem ter propriedades ou campos privados.
- Apenas um helper ativo por classe – Se houver mais de um helper para a mesma classe, apenas o último declarado será utilizado.
Quando usar um Class Helper?
Os Class Helpers são úteis quando queremos:
- Adicionar métodos de utilidade a classes existentes.
- Extender classes de bibliotecas sem alterar seu código-fonte.
- Melhorar a reutilização de código, tornando-o mais organizado e legível.
No entanto, devemos usá-los com cautela, pois sua utilização excessiva pode gerar código difícil de manter, principalmente quando há múltiplos helpers para uma mesma classe.
Criando um Class Helper para TEdit
Nosso objetivo é permitir que um TEdit receba um formato e, enquanto o usuário digita, o texto seja ajustado automaticamente.
Passos da implementação
- Criamos um Class Helper para
TEdit. - Definimos um método
FormatarTextoque recebe uma máscara (R$ ###,###.00,(##) #####-####, etc.). - Aplicamos essa formatação no evento
OnTypingouOnChange, garantindo que a máscara seja aplicada em tempo real.
Implementação do Class Helper
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
unit EditHelperUnit; interface uses System.SysUtils, System.Classes, FMX.Edit, System.Character; type TEditHelper = class helper for TEdit private function RemoverCaracteresNaoNumericos(const ATexto: string): string; function AplicarMascara(const AMascara, ATexto: string): string; public procedure AplicarFormato(const AMascara: string); end; implementation { Remove caracteres não numéricos para facilitar a aplicação da máscara } function TEditHelper.RemoverCaracteresNaoNumericos(const ATexto: string): string; var Ch: Char; begin Result := ''; for Ch in ATexto do if Ch.IsDigit then Result := Result + Ch; end; { Aplica a máscara ao texto digitado } function TEditHelper.AplicarMascara(const AMascara, ATexto: string): string; var i, j: Integer; Resultado: string; begin Resultado := ''; i := 1; j := 1; while (i <= Length(AMascara)) and (j <= Length(ATexto)) do begin if AMascara[i] = '#' then begin Resultado := Resultado + ATexto[j]; Inc(j); end else Resultado := Resultado + AMascara[i]; Inc(i); end; Result := Resultado; end; { Método que pode ser chamado no OnChange ou OnTyping do TEdit } procedure TEditHelper.AplicarFormato(const AMascara: string); var TextoFormatado: string; begin TextoFormatado := AplicarMascara(AMascara, RemoverCaracteresNaoNumericos(Self.Text)); Self.Text := TextoFormatado; { Move o cursor para o final do texto } Self.CaretPosition := Length(TextoFormatado); end; end. |
Como Usar no Formulário
Agora podemos utilizar o TEditHelper em qualquer TEdit. No evento OnTyping ou OnChange, basta chamar AplicarFormato, passando a máscara desejada.
Exemplo de Uso: Formatando como Moeda (R$ ###,###.00)
|
1 2 3 4 5 6 |
procedure TForm1.Edit1Typing(Sender: TObject); begin Edit1.AplicarFormato('R$ ###,###.00'); end; |
Exemplo de Uso: Formatando um Telefone ((##) #####-####)
|
1 2 3 4 5 6 |
procedure TForm1.EditTelefoneTyping(Sender: TObject); begin EditTelefone.AplicarFormato('(##) #####-####'); end; |
Explicação do Código
- RemoverCaracteresNaoNumericos → Remove qualquer caractere que não seja número, para facilitar a aplicação da máscara.
- AplicarMascara → Percorre a string original e substitui os caracteres
#pela entrada do usuário, preservando a formatação. - AplicarFormato → Método principal que pode ser chamado nos eventos
OnChangeouOnTypingdoTEdit.
Participe da Comunidade no Telegram
🚀 Quer continuar essa discussão e trocar ideias com outros desenvolvedores? Junte-se à nossa comunidade no Telegram! Lá, você pode comentar sobre o que achou deste artigo, tirar suas dúvidas e compartilhar suas experiências com Delphi e ainda discutir ou tirar suas dúvidas sobre os mais variados temas em uma comunidade com mais de 1.000 desenvolvedores.
🔗 Clique aqui para entrar na comunidade
Te vejo lá!
Conclusão
Os Class Helpers no Delphi são uma ferramenta poderosa para estender funcionalidades de classes existentes sem a necessidade de herança ou modificações diretas no código-fonte original. Eles são especialmente úteis quando trabalhamos com bibliotecas fechadas ou quando queremos adicionar métodos auxiliares para melhorar a reutilização e organização do código.
No exemplo prático deste artigo, criamos um Class Helper para TEdit, permitindo a formatação automática de textos em tempo real, um recurso muito útil para aplicações mobile desenvolvidas com FireMonkey. Esse tipo de abordagem melhora a experiência do usuário, garantindo que os dados sejam inseridos corretamente desde o momento da digitação.
Apesar das vantagens, é importante lembrar que o Delphi permite apenas um Class Helper ativo por classe por vez, o que pode ser uma limitação em projetos mais complexos. Ainda assim, se usados com planejamento, os Class Helpers são uma excelente alternativa para aprimorar a legibilidade, manutenibilidade e eficiência do código.
Se você gostou deste conteúdo, experimente aplicar Class Helpers em outras classes e descubra novas formas de otimizar seu desenvolvimento no Delphi! 🚀😊
