Design Patterns em Delphi

Por
Design Patterns em Delphi
Padrões de Projetos

Introdução

Nesse post iremos aprender sobre Design Patterns em Delphi, com exemplos práticos que você poderá aplicar no seu projeto.

O desenvolvimento de software é uma atividade complexa que requer soluções eficazes e reutilizáveis para problemas recorrentes. Design patterns, ou padrões de design, são soluções documentadas que foram testadas e comprovadas ao longo do tempo. Eles oferecem um modelo para resolver problemas de design de software de maneira eficiente e consistente. Neste artigo, discutiremos o que são design patterns, suas vantagens e desvantagens, e exploraremos alguns dos padrões de design mais comuns com exemplos práticos em Delphi.

O Que é Design Patterns

Design patterns são descrições gerais ou templates que podem ser seguidos para resolver problemas recorrentes em design de software. Eles não são implementações diretas, mas sim guias que ajudam os desenvolvedores a criar soluções robustas e flexíveis. A ideia principal por trás dos design patterns é capturar as melhores práticas e soluções experimentadas para problemas comuns, permitindo que os desenvolvedores as reutilizem em novos projetos.

Vantagens e Desvantagens dos Design Patterns em Delphi

Vantagens

  1. Reutilização de Código: Os design patterns promovem a reutilização de soluções, o que pode economizar tempo e esforço no desenvolvimento de software.
  2. Manutenção: Eles facilitam a manutenção e evolução do software, pois fornecem uma base sólida e compreensível para o código.
  3. Consistência: Usar design patterns torna o código mais consistente e legível, pois outros desenvolvedores familiarizados com os padrões podem entender rapidamente a estrutura do código.
  4. Qualidade do Software: A aplicação de design patterns ajuda a melhorar a qualidade do software, garantindo que soluções comprovadas sejam utilizadas para resolver problemas.

Desvantagens

  1. Complexidade: Em alguns casos, a aplicação de design patterns pode adicionar complexidade ao código, tornando-o mais difícil de entender para desenvolvedores menos experientes.
  2. Sobrecarga: O uso indevido de design patterns pode levar ao overengineering, onde o código se torna excessivamente estruturado para resolver problemas simples.
  3. Curva de Aprendizado: Desenvolvedores novos podem precisar de tempo para aprender e entender como aplicar corretamente os design patterns.

Introdução aos Padrões de Design Mais Comuns

Vamos agora explorar alguns dos padrões de design mais comuns e como implementá-los em Delphi: Singleton, Factory e Observer.

Singleton

O padrão Singleton garante que uma classe tenha apenas uma instância e fornece um ponto global de acesso a ela. Isso é útil em situações onde uma única instância de uma classe é necessária, como em gerenciadores de configuração ou conexões de banco de dados.

Explicação do Código

Definição da Classe

type
  TSingleton = class
  private
    class var FInstance: TSingleton;
    constructor Create; 
  public
    class function GetInstance: TSingleton;
  end;
  • TSingleton é a classe que implementa o padrão Singleton.
  • FInstance é uma variável de classe que armazenará a instância única da classe TSingleton.
  • O construtor Create é privado para impedir que outras partes do código criem instâncias diretamente.
  • GetInstance é uma função de classe pública que retorna a instância única da classe TSingleton.

Construtor Privado

constructor TSingleton.Create;
begin
  // Construtor privado para impedir instâncias múltiplas
end;
  • O construtor Create é declarado como privado. Isso impede que outras partes do código criem instâncias da classe TSingleton diretamente usando TSingleton.Create.
  • A implementação do construtor está vazia, mas poderia incluir qualquer inicialização necessária para a instância única.

Método GetInstance

class function TSingleton.GetInstance: TSingleton;
begin
  if not Assigned(FInstance) then
    FInstance := TSingleton.Create;
  Result := FInstance;
end;
  • GetInstance é uma função de classe pública que retorna a instância única da classe TSingleton.
  • A função verifica se FInstance está atribuído usando not Assigned(FInstance). Se não estiver, cria uma nova instância de TSingleton e a atribui a FInstance.
  • Finalmente, a função retorna FInstance, garantindo que todos os chamadores recebam a mesma instância.

Fluxo de Execução

  1. Primeira Chamada a GetInstance:
    • FInstance é nil, então TSingleton.Create é chamado para criar a instância.
    • A instância recém-criada é atribuída a FInstance.
    • A instância única é retornada.
  2. Chamadas Subsequentes a GetInstance:
    • FInstance já está atribuída.
    • A função simplesmente retorna a instância existente.

Benefícios do Padrão Singleton

  • Instância Única: Garante que apenas uma instância da classe exista, economizando recursos e evitando inconsistências.
  • Ponto Global de Acesso: Facilita o acesso à instância única de qualquer lugar do código.

Possíveis Desvantagens

  • Dificuldade de Teste: Pode ser mais difícil testar classes Singleton, especialmente em testes unitários, devido à sua natureza global e estado compartilhado.
  • Acoplamento: Pode introduzir um acoplamento global no sistema, tornando-o mais difícil de modificar ou estender.

Código completo

type
  TSingleton = class
  private
    class var FInstance: TSingleton;
    constructor Create; 
  public
    class function GetInstance: TSingleton;
  end;

constructor TSingleton.Create;
begin
  // Construtor privado para impedir instâncias múltiplas
end;

class function TSingleton.GetInstance: TSingleton;
begin
  if not Assigned(FInstance) then
    FInstance := TSingleton.Create;
  Result := FInstance;
end;

Factory

O padrão Factory define uma interface para criar um objeto, mas permite que as subclasses alterem o tipo de objeto que será criado. Este padrão é útil para a criação de objetos sem especificar a classe exata dos objetos que serão criados.

Explicação do Código

Interface IVehicle

type
  IVehicle = interface
    procedure Drive;
  end;
  • IVehicle é uma interface que define o método Drive.
  • Qualquer classe que implemente essa interface deve fornecer uma implementação para o método Drive.

Implementação das Classes TCar e TTruck

TCar = class(TInterfacedObject, IVehicle)
  procedure Drive;
end;

TTruck = class(TInterfacedObject, IVehicle)
  procedure Drive;
end;
  • TCar e TTruck são classes que implementam a interface IVehicle.
  • Ambas as classes herdam de TInterfacedObject, o que facilita a implementação da interface IVehicle.

Implementação do Método Drive

procedure TCar.Drive;
begin
  Writeln('Driving a car.');
end;

procedure TTruck.Drive;
begin
  Writeln('Driving a truck.');
end;
  • A classe TCar implementa o método Drive exibindo a mensagem “Driving a car.”.
  • A classe TTruck implementa o método Drive exibindo a mensagem “Driving a truck.”.

Classe TVehicleFactory

TVehicleFactory = class
  class function CreateVehicle(VehicleType: string): IVehicle;
end;
  • TVehicleFactory é uma classe que contém um método de classe CreateVehicle.
  • O método CreateVehicle é responsável por criar e retornar uma instância de um objeto que implementa a interface IVehicle com base no tipo de veículo especificado.

Implementação do Método CreateVehicle

class function TVehicleFactory.CreateVehicle(VehicleType: string): IVehicle;
begin
  if VehicleType = 'Car' then
    Result := TCar.Create
  else if VehicleType = 'Truck' then
    Result := TTruck.Create
  else
    raise Exception.Create('Unknown vehicle type');
end;
  • O método CreateVehicle recebe um parâmetro VehicleType do tipo string.
  • Ele verifica o valor de VehicleType:
  • Se VehicleType for “Car”, ele cria e retorna uma instância de TCar.
  • Se VehicleType for “Truck”, ele cria e retorna uma instância de TTruck.
  • Se VehicleType não for nenhum dos valores esperados, ele lança uma exceção indicando um tipo de veículo desconhecido.

Fluxo de Execução

  1. Definição da Interface: A interface IVehicle é definida com o método Drive.
  2. Implementação da Interface: As classes TCar e TTruck implementam a interface IVehicle e fornecem a implementação para o método Drive.
  3. Fábrica de Veículos: A classe TVehicleFactory contém um método de classe CreateVehicle que cria instâncias de TCar ou TTruck com base no parâmetro VehicleType.

Benefícios do Padrão Factory Method

  • Desacoplamento: O padrão desacopla o código de criação de objetos do código que utiliza esses objetos, promovendo uma maior flexibilidade.
  • Extensibilidade: Novos tipos de veículos podem ser adicionados sem modificar a lógica de criação existente na fábrica.
  • Manutenção: Facilita a manutenção do código, pois a lógica de criação está centralizada em um único lugar.

Possíveis Desvantagens

  • Complexidade Adicional: Pode adicionar complexidade ao código, especialmente em sistemas simples onde a criação direta de objetos seria suficiente.
  • Sobrecarga: Pode levar ao overengineering se usado indevidamente para problemas que não requerem tal nível de abstração.

Código completo

type
  IVehicle = interface
    procedure Drive;
  end;

  TCar = class(TInterfacedObject, IVehicle)
    procedure Drive;
  end;

  TTruck = class(TInterfacedObject, IVehicle)
    procedure Drive;
  end;

  TVehicleFactory = class
    class function CreateVehicle(VehicleType: string): IVehicle;
  end;

procedure TCar.Drive;
begin
  Writeln('Driving a car.');
end;

procedure TTruck.Drive;
begin
  Writeln('Driving a truck.');
end;

class function TVehicleFactory.CreateVehicle(VehicleType: string): IVehicle;
begin
  if VehicleType = 'Car' then
    Result := TCar.Create
  else if VehicleType = 'Truck' then
    Result := TTruck.Create
  else
    raise Exception.Create('Unknown vehicle type');
end;

Observer

O padrão Observer define uma dependência um-para-muitos entre objetos, onde quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente. Este padrão é útil para implementar sistemas de eventos e notificações.

O código apresentado implementa o padrão de design Observer em Delphi. O padrão Observer define uma dependência um-para-muitos entre objetos, onde quando um objeto (o sujeito) muda de estado, todos os seus dependentes (os observadores) são notificados e atualizados automaticamente. Abaixo está uma explicação detalhada do código.

Explicação do Código

Interface IObserver

type
  IObserver = interface
    procedure Update;
  end;
  • IObserver é uma interface que define o método Update.
  • Qualquer classe que implemente essa interface deve fornecer uma implementação para o método Update.

Classe TSubject

TSubject = class
private
  FObservers: TList<IObserver>;
public
  constructor Create;
  destructor Destroy; override;
  procedure Attach(Observer: IObserver);
  procedure Detach(Observer: IObserver);
  procedure Notify;
end;
  • TSubject é a classe que mantém uma lista de observadores e notifica-os sobre qualquer mudança.
  • FObservers é uma lista de objetos que implementam a interface IObserver.

Construtor e Destrutor de TSubject

constructor TSubject.Create;
begin
  FObservers := TList<IObserver>.Create;
end;

destructor TSubject.Destroy;
begin
  FObservers.Free;
  inherited;
end;
  • O construtor Create inicializa a lista de observadores (FObservers).
  • O destrutor Destroy libera a memória alocada para a lista de observadores e chama o destrutor da classe base (inherited).

Métodos Attach, Detach e Notify

procedure TSubject.Attach(Observer: IObserver);
begin
  FObservers.Add(Observer);
end;

procedure TSubject.Detach(Observer: IObserver);
begin
  FObservers.Remove(Observer);
end;

procedure TSubject.Notify;
var
  Observer: IObserver;
begin
  for Observer in FObservers do
    Observer.Update;
end;
  • Attach adiciona um observador à lista FObservers.
  • Detach remove um observador da lista FObservers.
  • Notify percorre a lista de observadores e chama o método Update de cada um para notificá-los sobre uma mudança.

Classe TConcreteObserver

TConcreteObserver = class(TInterfacedObject, IObserver)
  procedure Update;
end;
  • TConcreteObserver é uma classe concreta que implementa a interface IObserver.
  • Esta classe herda de TInterfacedObject, que facilita a implementação de interfaces.

Implementação do Método Update de TConcreteObserver

procedure TConcreteObserver.Update;
begin
  Writeln('Observer updated.');
end;
  • A implementação do método Update exibe a mensagem “Observer updated.” quando o método é chamado.

Fluxo de Execução

  1. Definição da Interface: A interface IObserver é definida com o método Update.
  2. Classe Sujeito (TSubject):
    • Mantém uma lista de observadores (FObservers).
    • Permite que os observadores se inscrevam (Attach) e cancelem a inscrição (Detach).
    • Notifica todos os observadores sobre mudanças (Notify).
  3. Classe Observador Concreto (TConcreteObserver):
    • Implementa a interface IObserver.
    • Fornece a implementação do método Update.

Exemplo de Uso

Para usar o padrão Observer com as classes acima, você pode fazer o seguinte:

var
  Subject: TSubject;
  Observer1, Observer2: IObserver;
begin
  Subject := TSubject.Create;
  try
    Observer1 := TConcreteObserver.Create;
    Observer2 := TConcreteObserver.Create;

    Subject.Attach(Observer1);
    Subject.Attach(Observer2);

    Subject.Notify;  // Isso exibirá "Observer updated." duas vezes

    Subject.Detach(Observer1);

    Subject.Notify;  // Isso exibirá "Observer updated." uma vez
  finally
    Subject.Free;
  end;
end;

Benefícios do Padrão Observer

  • Desacoplamento: O padrão desacopla o sujeito dos seus observadores. O sujeito não precisa saber detalhes específicos dos observadores, apenas que eles implementam a interface IObserver.
  • Flexibilidade: Novos tipos de observadores podem ser adicionados sem modificar o código do sujeito.
  • Manutenção: Facilita a manutenção do código, pois a lógica de notificação está centralizada no sujeito.

Possíveis Desvantagens

  • Complexidade: Pode adicionar complexidade ao sistema, especialmente se houver muitos observadores.
  • Desempenho: Notificar muitos observadores pode impactar o desempenho.

Código completo

type
  IObserver = interface
    procedure Update;
  end;

  TSubject = class
  private
    FObservers: TList<IObserver>;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Attach(Observer: IObserver);
    procedure Detach(Observer: IObserver);
    procedure Notify;
  end;

  TConcreteObserver = class(TInterfacedObject, IObserver)
    procedure Update;
  end;

constructor TSubject.Create;
begin
  FObservers := TList<IObserver>.Create;
end;

destructor TSubject.Destroy;
begin
  FObservers.Free;
  inherited;
end;

procedure TSubject.Attach(Observer: IObserver);
begin
  FObservers.Add(Observer);
end;

procedure TSubject.Detach(Observer: IObserver);
begin
  FObservers.Remove(Observer);
end;

procedure TSubject.Notify;
var
  Observer: IObserver;
begin
  for Observer in FObservers do
    Observer.Update;
end;

procedure TConcreteObserver.Update;
begin
  Writeln('Observer updated.');
end;

Utilizar os conceitos de Padrões de Projetos (Design Patterns) requer uma base estruturada de orientação a objetos.

Segue o link de um exemplo de código completo utilizando orientação a objetos:

https://github.com/Gisele-de-Melo/Interface

Conclusão

Os design patterns são ferramentas poderosas que ajudam a resolver problemas recorrentes de design de software de maneira eficiente e reutilizável. Em Delphi, a aplicação desses padrões pode melhorar a manutenibilidade, a qualidade e a escalabilidade do código. Embora existam algumas desvantagens, como a complexidade adicional e a curva de aprendizado, os benefícios geralmente superam esses desafios. Entender e aplicar padrões como Singleton, Factory e Observer pode fazer uma grande diferença na qualidade do seu software, tornando-o mais robusto e preparado para mudanças futuras.

Posts Relacionados

Princípios SOLID em Delphi

Refatoração de Código

Deixe um comentário