Fala ai Radizeiros e Radizeiras, tudo bem com vocês?
Irei mostrar um recurso que o Delphi tem que facilita na criação dos padrões de projetos, fazendo com que sua programação seja extremamente RAD.
Para lhe mostrar iremos criar um projeto novo no Delphi, em Firemonkey mesmo.
Como o Delphi nos auxilia a criar um padrão por exemplo do GOF?
Com o nosso novo projeto, vamos na aba Model View no Projetcs, ao clicar você irá receber uma mensagem perguntando se você deseja adicionar o suporte ao modelo agora para esse projeto especifico.
Ao aceitar irá habilitar a aba Model View, abrindo o escopo da modelagem do projeto.
Esse conceito do Model View o Together, um recurso dentro do Delphi, é muito amplo, mas aqui em nosso blog irei abordar a parte do Design Patterns.
No Model View nós temos todo o conceito de UML que você pode implementar, por exemplo, diagrama de classe, basicamente você pode implementar quase todos os modelos de UML.
Vamos pegar nossa Unit1 e com dois cliques nesse iremos abrir o modelo de classes.
Você pode observar na imagem abaixo que ele já espelha o TForm1 em forma de modelo, que é minha classe criada quando criamos o TForm1.
Ela está espelhando a classe do formulário.
type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.fmx}
end.
Além do que já temos no nosso modelo, podemos criar nosso Design Pattern.
Basta clicar com o botão direito no diagrama e clicar em Create by Pattern.
Neste momento já posso implementar facilmente qualquer Design Pattern do GOF.
Como podemos observar na Wizard, que o Delphi já trás para nós os padrões do GOF que são: Comportamentais, criacionais e estruturais.
Você pode observar que temos todos os padrões do GOF, e por exemplo, vamos criar um padrão Singleton.
Feito o procedimento acima, ele já implementa para nós uma classe TSingleton com o GetInstance dele, como podemos ver no nosso diagrama.
Se observarmos a nossa Unit1, em nosso código o padrão Singleton implementado dentro de nossa classe, sem eu precisar programar esse padrão, sem ter que programar nenhuma linha de código manualmente.
...
TSingleton = class
strict private
class var FInstance: TSingleton;
constructor Create;
public
class function GetInstance: TSingleton;
end;
...
constructor TSingleton.Create;
begin
inherited;
end;
class function TSingleton.GetInstance: TSingleton;
begin
If FInstance = nil Then
begin
FInstance := TSingleton.Create();
end;
Result := FInstance;
end;
Viu como o Delphi nos permite ser muito RAD utilizando orientação a objeto, e trabalhando com o padrões de projetos, seja ele qual for.
E caso você queira criar um outro padrão em seu projeto, como por exemplo o Abstract Factory.
Observe que ele já mostra quais serão as classes que irão ser implementadas, ConcreteFactory, ConcreteProduct e as duas interfaces que compõe o Abstract Factory.
Veja no diagrama que ele já implementou tanto as interfaces, quanto as classes que vamos trabalhar no Abstract Factory.
type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
end;
IAbstractProduct = interface
end;
IAbstractFactory = interface
function CreateIAbstractProduct: IAbstractProduct;
end;
TConcreteProduct = class(TInterfacedObject, IAbstractProduct)
end;
TConcreteFactory = class(TInterfacedObject, IAbstractFactory)
public
function CreateIAbstractProduct: IAbstractProduct;
end;
var
Form1: TForm1;
implementation
{$R *.fmx}
function TConcreteFactory.CreateIAbstractProduct: IAbstractProduct;
begin
Result := TConcreteProduct.Create();
end;
end.
Em nossa Unit1 podemos observar nossa classe do formulário, as interfaces e as classes, tanto a Factory quanto o Product.
A partir dai é só conhecermos como trabalhar e utilizarmos esses padrões.
Você deve padronizar, utilizar um padrão de projeto(Desing Patter), para padronizar o seu software, criando suas adaptações, que funcione legal para você.
Nós também podemos criar os nossos próprios padrões usando o Together.
Em uma nova Unit criada no nosso projeto iremos implementar um novo padrão.
Type
iPatternMasterClass = interface
end;
TPatternMasterClass = class(TInterfacedObject, iPatternMasterClass)
public
constructor Create;
destructor Destroy; override;
class function New : iPatternMasterClass;
end;
implementation
{ TPatternMasterClass }
constructor TPatternMasterClass.Create;
begin
end;
destructor TPatternMasterClass.Destroy;
begin
inherited;
end;
class function TPatternMasterClass.New: iPatternMasterClass;
begin
Result := Self.Create;
end;
end.
Eu criei um padrão que eu gosto de utilizar para todas as minhas classes.
Para que esse padrão esteja implementado dentro do Model View, ele precisa estar aberto no diagrama de classes.
Observe que temos nossa interface e a classe que à implementa, com essas classes selecionadas, clicando com o botão direito iremos clicar em Save as Pattern…
Irá abrir uma nova tela onde daremos um nome para esse padrão e algumas descrições.
Ao clicar em next teremos as classes e interfaces que serão criadas nesse padrão.
Clicando navamente em next, iremos visualiza em qual local devemos salvar, que será dentro de Custom Pattern, que são os padrões customizados que eu estou criando.
Agora para utilizamos basta seguir o mesmo padrão usado na criação dos demais padrões.
Olha ele ai!
Viu como é fácil utilizar o Together do Delphi?
E ainda mais, podemos criar nossos próprios padrões.
Se você viu esses conceitos de interfaces, classes que as implementam, Design pattern e ficou um pouco perdido, não se preocupe, estamos na semana Delphi Updates, nesta semana estaremos disponibilizando diversos conteúdos que iremos utilizar todos esses conceitos e levar a sua aplicação a outro nível.
Basta clicar no link abaixo e fazer parte do grupo vip do WhatsApp e você receberá os links para todos os conteúdos que serão disponibilizados.
CLIQUE AQUI E FAÇA PARTE DO NOSSO GRUPO VIP DA SEMANA DELPHI UPDATES.
