Lorival Smolski Chapuis

Posts Tagged ‘GoF’

Design Pattern: Facade

Definição segundo GoF: Oferecer uma interface única para um conjunto de interfaces de um subsistema. Façade define uma interface de nível mais elevado que torna o subsistema mais fácil de usar.

Exemplo baseado no mundo real: A sala de estar…. ah! sala de estar, quanta beleza existe em uma boa e tecnológica sala de estar… quantos de nós já teve a maravilhosa idéia de montar seu home theater em sua sala de estar, tornando-a um fantástico embolado de fios e aparelhos eletro-eletrônicos? Pois bem, nosso objetivo aqui é criar uma sala simples e bacana tecnológicamente. Vamos precisar de:

• Uma TV 32 polegadas LCD (poderia ser LED eu sei, mas vamos pelo  mais barato);
• Um DVD Player conectado a nossa TV;
• Um Aparalho de som 7.1 para usar como rádio/CD/MP3  para conectar com nosso DVD Player;
• Um PlayStation3 conectado a TV;
• Uma luz ambiente regulável.

Poderia ser mais coisas, mas vamos começar pelo simples. Agora você sentou no sofá e pegou na mão os controles:

• da TV;
• do DVD Playser;
• do aparalhode som;
• da luz ambiente.

Já imaginou o trabalho que vai ter para usar tudo isso integrado? E se tivessemos apenas um controle que reuni-se as principais funcionalidades destes 4 e ainda conecta-se nosso Play 3 junto? Não seria uma maravilha? Pois bem, este é o objetivo do Façade ou fachada: servir como uma interface única para um conjunto de interfaces.

Aplicações:

• Sempre que for desejável criar uma interface para um conjunto de objetos com o objetivo de facilitar o uso da aplicação;
• Reduzir a complexidade do relacionamento entre uma classe relativa ao cliente e as demais classes utilitárias [Junior, 2004];
• Redução de dependência entre o cliente e as classes existentes nos subsistemas, ocasionando a redução da coesão do sistema.

Vantagens:

• Permite que objetos individuais cuidem de uma única tarefa, deixando que a fachada se encarregue de divulgar as suas operações;
• Reduz dependências de compilação, possivelmente complexas ou circulares;
• Não evita que aplicações possam acessar diretamente as subclasses do sistema, se assim o desejarem [Junior, 2004];

Desvantagens:

• Necessário saber a classe concreta do criador de instâncias;

Observações:

• Fachadas são normalmente implementadas com singleton;
• Uma fachada apenas com métodos estáticos são chamadas de Utility.

Diagrama de classe:

Diagrama simplificado

Implementação em C#:

public class Client
{
    public void Cooking() //-- Quando o cliente for cozinhar algo para comer...
    {
        //-- Código especialista
        HomeTheaterFacade homeTheater = new HomeTheaterFacade();
        homeTheater.WatchMovie();
        //-- Código especialista
    }

    //-- Outros métodos úteis aqui
}

A codificação inteira deste post, juntamente com exemplos será feita em outro post.

Abrs a todos e até a próxima.

“Quando vemos um gigante, temos primeiro de examinar a posição do sol e observar para termos certeza de que não é a sombra de um pigmeu.” Friedrich Novalis

Design Pattern: Singleton

Definição segundo GoF:  Garantir que uma classe só tenha uma única instância, e prover um ponto de acesso global a ela.

Exemplo baseado no mundo real: Se você tem um objeto que é uma montadora de carros onde sua responsabilidade é criar vários objetos carros. Existe a necessidade de criar a instância de uma nova montadora a cada vez que for criar um novo carro? A resposta é simples: iniciamos o sistema, criamos uma única instância da montadora, quando necessário (isto chama-se instancialização preguiçosa), e usamos ela para criar todos os carros necessários.

Peraí?! Isto não é a mesma coisa que criar uma variável global e utilizá-la? Não! O singleton é usado justamente para não ter as famosas variáveis globais. Ao invés de ficar criando variáveis estáticas pelo sistema, acessando de tudo que é forma, criamos uma classe, garantimos que só vai existir uma única instância dela em memória e criamos um único ponto de acesso para pegar sua instância.

Aplicações:

• Um objeto único de acesso a banco de dados;
• Um objeto único de acesso a um arquivo de log;
• Um objeto único de acesso a configurações gerais do sistema;
• Um objeto único que representa um vídeo usado inúmeras vezes no sistema;
• Uma objeto facade (fachada) único. Este é um pattern que será visto mais adiante.

Vantagens:

• Não ter variáveis globais sendo acessadas dentro do software;
• Ter sempre um único local responsável por uma informação estática (instância da classe) (static);
• Organizar a modelagem e codificação em classes;

Desvantagens:

• Qualidade da implementação depende da linguagem;
• Não é tão simples controlar em ambiente distribuído;

Observações: Cuidado na implementação multi-thread. Veja os exemplos de códigos abaixo.

Diagrama de classe:

Fonte: Livro "Use a cabeça!: Padrões de projetos"

Implementação em C#:

public class Singleton
{
    private static Singleton uniqueInstance;
    //-- Outras variáveis de instância úteis aqui

    private Singleton() { } //-- Não pode ser instanciado

    public static Singleton GetInstance()
    {
        if (uniqueInstance == null)
            uniqueInstance = new Singleton();
        return uniqueInstance;
    }

    //-- Outros métodos úteis aqui
}

Close no código:

Fonte: Livro "Use a cabeça!: Padrões de projetos"

Implementação comum em C# thread-safe (multi-threads) sem instancialização preguiçosa:

public class Singleton
{
    private static Singleton uniqueInstance = new Singleton();
    //-- Outras variáveis de instância úteis aqui

    private Singleton() { } //-- Não pode ser instanciado

    public static  Singleton GetInstance()
    {
        return uniqueInstance;
    }

    //-- Outros métodos úteis aqui
}

Implementação em C# thread-safe (multi-threads) com instancialização preguiçosa, variável volatile e lock:

public class Singleton
{
    private static object sync = new object();
    private static volatile Singleton uniqueInstance;
    //-- Outras variáveis de instância úteis aqui

    private Singleton() { } //-- Não pode ser instanciado

    public static Singleton GetInstance()
    {
        if (uniqueInstance == null)
        {
            lock (sync)
            {
                if (uniqueInstance == null)
                    uniqueInstance = new Singleton();
            }
        }
        return uniqueInstance;
    }

    //-- Outros métodos úteis aqui
}

Com o modificador volatile você garante que, independente do processo que esteja acessando a váriavel/propriedade, ele pegará o valor atual da váriavel/propriedade. Um post sobre modificadores virá mais a frente.

Chamada da classe Singleton em C#:

     Singleton sing = Singleton.GetInstance();

Os exemplos em C# são apenas demonstrativos, se alguêm quiser enviar exemplos em outras linguagens eu altero o post e coloco o respectivo nome do autor .

Abrs a todos e até a próxima.

“Em questões de estilo, nade contra corrente; em questões de princípios, fique firme como uma rocha.” Thomas Jefferson