O pattern Façade (fachada), pertencente ao catálogo GOF, possui a intenção de estruturar o sistema de forma que se crie uma barreira (fachada) entre um conjunto complexo de instruções (subsistema) e os desenvolvedores (usuários), de forma que o subsistema torne-se mais fácil de ser utilizado e entendido, além de tornar-se reutilizável e confiável por executar sempre a mesma seqüência de passos. (Bishop, 2007, p. 93) (GoF, 1995, p. 179)

“Fornece uma interface unificada para um conjunto de interfaces em um subsistema. O Façade define uma interface de nível mais alto que torna o subsistema mais fácil de usar.” (GoF, 1995, p. 179)

 

A figura acima demonstra um subsistema sendo utilizado por múltiplos pontos da aplicação, sendo que tais utilizações nem sempre iniciam do mesmo ponto e não garantem completa execução das instruções necessárias. De forma oposta, o outro sistema possui uma interface única, onde o acesso ao subsistema é feito de forma padronizada e pré-definida.

Como exemplo, para aplicação do pattern Façade, utilizaremos o cenário onde inumeros acessos à base de dados que são necessários durante a aplicação.

O processo de acesso e recuperação de informações dentro de base de dados é um processo complexo e que exige uma sequência linear de instruções. Tal sequência se não executada na ordem correta, pode acarretar em perdas de desempenho ou em erros de conexão com a base de dados.

Para contornarmos tal situação o pattern Façade indica a criação de uma classe que agrupe o conjunto complexo de instruções do subsistema dentro de um método, e que este método seja executado ao invés dos múltiplos acessos feitos ao subsistema. (Freeman, 2005, p. 220) (Larman, 2004, p. 468)

A figura abaixo apresenta a forma como modelamos o conjunto complexo de acesso a dados do subsistema Microsoft ADO.Net com base nas regras de implementação do padrão Façade.

O código abaixo demonstra a forma como o subsistema de acesso a dados pode ser codificado conforme as regras de implementação do pattern Façade.

public class DataCommand
{
    static string myConnectionString =
        System.Configuration.ConfigurationManager.
        ConnectionStrings["DesignPatterns.ConnectionString"].
        ConnectionString;

    public static DataSet GetDataSet(string SQLCommand)
    {
        SqlConnection oConn = new SqlConnection(myConnectionString);
        DbDataAdapter dAdapter = new SqlDataAdapter(SQLCommand, oConn);
        DataSet dsReturn = new DataSet();
        try
        {
            dAdapter.Fill(dsReturn);
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            oConn.Close();
        }
        return dsReturn;

    }

    public static DataTable GetDataTable(string SQLCommand)
    {
        return GetDataSet(SQLCommand).Tables[0];
    }

    public static int ExecuteCommand(string SQLCommand)
    {
        int returnValue = 0;
        SqlConnection oConn = new SqlConnection(myConnectionString);
        DbCommand oCommand = new SqlCommand(SQLCommand, oConn);
        try
        {
            oConn.Open();
            returnValue = oCommand.ExecuteNonQuery();
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            oConn.Close();
        }
        return returnValue;
    }
}

 

Desta forma, conseguimos economizar muito código e também conseguimos padronizar a sua execução, adicionando mais segurança a execução da aplicação. Outra vantagem é o impacto na manutenabilidade do código, pois passamos a dar suporte a pequenos blocos que não se repetem inumeras vezes na aplicação.

O uso do design pattern Façade também simplifica nosso código, permitindo que torne-se mais compacto e inteligível. Abaixo temos um exemplo da execução de um comando na base de dados, podemos notar como o código necessário tornou-se muito mais simples:

class Program
{
    static void Main(string[] args)
    {
        DataSet dsReturn =
            DataCommand.GetDataSet("Select * From tbCliente");
    }
}

Espero que aproveitem.

Obrigado e []s!

Por

Fernando Henrique Inocêncio Borba Ferreira

Microsoft Most Valuable Professional – Data Platform Development

Referências:

BISHOP, Judith; C# 3.0 Design Patterns; O’Reilly; 2007.

GoF – HELM, Richard; VLISSIDES, John; JOHNSON , Ralph; GAMMA , Erich; Design Pattern – elements of reusable object-oriented software; BookMan; 1995.

LARMAN, Craig; Applying UML and patterns: an introduction to object-oriented analysis and design and the unified process; BookMan; 2004.

FREEMAN, Eric, FREEMAN, Elisabeth; Head First – Design Patterns; O’Reilly Media;  Editora Alta Books Ltda; 2ª Edição Revisada; 2005.