Atenção: esse artigo tem uma palestra complementar. Clique e assista!

Atenção: esse artigo tem dois vídeos complementares.
Clique e assista o primeiro!
Clique e assista o segundo!

Podemos definir design patterns como soluções bem experimentadas para problemas conhecidos. Apesar de o termo ser bastante conhecido na Engenharia de Software, ele teve origem na Engenharia Civil, através dos trabalhos do arquiteto austríaco Chistopher Alexander que, nas décadas de 60 e 70, produziu um método estruturado para descrição de boas práticas de projeto dentro de uma área de conhecimento.

No mundo da TI, um dos livros mais importantes sobre padrões é Design Patterns Elements of Reusable Object-Oriented Software, escrito por Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, também conhecidos como GoF, ou Gang of Four. Neste livro estão descritos 23 padrões de modelagem baseados no conhecimento prático dos autores. Estes padrões estão divididos em padrões de criação (creational patterns), que tratam do processo de instanciação de classes; padrões estruturais (structural patterns), que tratam da composição dos objetos; e padrões comportamentais (behavioral patterns), que se preocupam com a comunicação entre os objetos.

Neste artigo vamos comentar e exemplificar o uso de dois padrões descritos pela GoF. São os design patterns conhecidos como Strategy e Flyweight. O primeiro permite que diferentes algoritmos sejam alternados de acordo com a necessidade, enquanto que o segundo provê uma forma de minimizar o uso de memória dos aplicativos, através de cache de objetos. Depois, vamos demonstrar que os padrões não trabalham isolados, mas possuem relacionamentos. Os exemplos que serão vistos são simples, mas possuem todos os elementos necessários para a implementação do padrão. Eles foram desenvolvidos em C#, utilizando a ferramenta Visual Studio 2010.

Conceitualizando o padrão Strategy

O padrão Strategy consiste em se possuir vários algoritmos, ou estratégias, encapsulados em uma classe chamada Context. O programa cliente pode selecionar um desses diferentes algoritmos, de acordo com a situação. Em alguns casos, a classe Context pode até decidir qual é a melhor no momento. O interessante é que essa escolha é feita em tempo de execução.

Com esse padrão, podemos mais facilmente adicionar novos algoritmos, alterar os já existentes ou estender suas funcionalidades.

A Figura 1 ilustra o diagrama UML que define este padrão. Temos os seguintes elementos:

• Context – é a classe que mantém a informação contextual para que um algoritmo possa funcionar. Serve de mediador entre o cliente e os algoritmos;

• Strategy – é a interface, o contrato que define todas as operações comuns que o algoritmo deve suportar. Perceba que a classe Context possui um atributo deste tipo e que servirá para centralizar todas as chamadas;

• ConcreteStrategy – são os próprios algoritmos. Podemos ter quantas classes desse tipo forem necessárias, cada uma representando um algoritmo diferente.

Figura 1. Diagrama UML para o padrão Strategy

Em resumo, este padrão pode ser aplicado quando você possuir uma aplicação onde existem diversas formas de se fazer uma coisa, onde a decisão de quando utilizar um algoritmo ou outro é feita de acordo com a necessidade.

Alternando algoritmos - Exemplo

Para poder demonstrar a utilidade do padrão Strategy, vamos supor uma aplicação que faça o cálculo de área e perímetro de figuras geométricas. Este tipo de rotina teria utilidade, por exemplo, em sistemas para cálculo de gastos de materiais em uma fábrica de embalagens.

Antes do exemplo, vamos relembrar alguns conceitos de geometria que são utilizados aqui. O cálculo do perímetro de um retângulo é a soma de todos os seus lados; já sua área é sua altura multiplicada pela largura. Para círculos, o perímetro é obtido multiplicando-se o raio pela constante (pi); sua área é a multiplicação dessa mesma constante pelo raio elevado ao quadrado. Aqui, estamos considerando o raio igual à metade da altura do objeto, para simplificar o exemplo.

A Listagem 1 contém o código da aplicação que faz o consumo de um componente responsável pelos cálculos. Este componente, chamado CalculadoraGeometrica, possui dois métodos: CalcularArea e CalcularPerimetro. Coincidentemente, os dois possuem a mesma assinatura. Recebem três parâmetros, que são:

1. Tipo da figura que vamos efetuar o cálculo, sendo ele um retângulo, círculo etc. Temos os valores possíveis para esses parâmetro definidos no enumerador TipoFigura;

2. A altura da figura;

3. A largura da figura.

Nesse código, percorremos um array de objetos contendo as informações das figuras e efetuando uma chamada ao componente para os cálculos de áreas e perímetros, sendo que essas informações são exibidas na tela.

Listagem 1. Aplicação que consome o componente de cálculo de áreas e perímetros

  using System;
  using ExemploStrategy.SemPadraoAlterado;
   
  namespace ExemploStrategy
  {
      class Program
      {
          static void Main(string[] args)
          {
              var figuras = new[] {
                  new { Tipo = TipoFigura.Retangulo, Altura = 10.0, Largura = 50.0 }
                  , new { Tipo = TipoFigura.Retangulo, Altura = 10.0, Largura = 40.0 }
                  , new { Tipo = TipoFigura.Circulo, Altura = 30.0, Largura = 30.0 }
                  , new { Tipo = TipoFigura.Retangulo, Altura = 10.0, Largura = 20.0 }
                  , new { Tipo = TipoFigura.Retangulo, Altura = 10.0, Largura = 10.0 }
                  , new { Tipo = TipoFigura.Circulo, Altura = 20.0, Largura = 20.0 }
                  , new { Tipo = TipoFigura.Retangulo, Altura = 10.0, Largura = 20.0 }
              };
              CalculadoraGeometrica calculadora = new CalculadoraGeometrica();
              Console.WriteLine(" Figura              | Altura  | Largura  | Area    | Perimetro");
              Console.WriteLine(" --------------------------------------------------------------");
              foreach (var figura in figuras)
              {
                  Console.WriteLine(" {0, -20}| {1:00.00}   | {2:00.00}    | {3:000.00}  | {4:000.00}"
                      , figura.Tipo
                      , figura.Altura
                      , figura.Largura
                      , calculadora.CalcularArea(figura.Tipo, figura.Altura, figura.Largura)
                      , calculadora.CalcularPerimetro(figura.Tipo, figura.Altura, figura.Largura));
              }
              Console.ReadLine();
          }
      }
   
      public enum TipoFigura : int
      {
          Retangulo = 1,
          Circulo = 2
      }
  } ...