ASP .NET - Acessando PostGreSQL em Camadas e com padrões de projeto II


Na segunda parte do meu artigo ASP .NET - Acessando PostGreSQL em Camadas e com padrões de projeto vamos definir as classes da camada de negócios através das quais iremos acessar a camada de acesso a dados - DAL, criada na primeira parte do artigo.

Lembrando que a camada de negócios já foi criada como um projeto do tipo Class Library e que tem como referência o projeto CamdaAcessoDados e o projeto Entidades conforme exibe a figura abaixo obtida no Project Dependencies:

Na verdade ao invés de criar as camadas como projetos eu poderia ter criado uma hierarquia de pastas na solução e ter realizado uma separação lógica entre as camadas , a vantagem de criar um projeto e que podemos distribuir a dll do projeto para referenciar outros projetos. Mas essa decisão depende da complexidade do projeto que estamos tratando.

A camada de negócios geralmente contém as regras do negócio e as validações das solicitações antes de serem repassadas para a camada de acesso a dados. Quando eu digo regra de negócio eu me refiro a regras específicos pertinentes ao sua aplicação como um cálculo complexo, ou rotina que realiza uma operação que só o seu negócio tem e que o diferencia dos demais, além é claro das regras gerais pertinentes ao qualquer negócio como cálculo de impostos, alíquotas, etc.

Como nossa aplicação é muito incipiente e no momento no objetivo é apenas acessar os dados de uma tabela do banco de dados  e exibi-lo em uma página ASP .NET não teremos que nos preocupar com regras de negócio mas apenas vamos criar a estrutura que poderá ser usada para atingir o nosso objetivo e no futuro implementar tais regras quando elas se fizerem necessárias.

Aqui eu vou mostrar na figura abaixo (que eu adaptei de uma figura encontrada) um esquema do que seria a arquitetura da nossa solução:

Nesta figura eu estou exibindo a arquitetura da nossa solução e detalhando a camada de negócios onde temos:
  • A classe FactoryDAO.cs que usa o padrão Factory e serve para criar instâncias das classes;
  • A classe Facade.cs que usa o padrão Facade e permite agrupar em uma única classe as chamadas aos métodos que iremos usar;
  • A classe AlunoFacade.cs onde efetivamente chamamos os métodos que vamos usar para acessar a camada de acesso a dados;

Obs: Tanto a classe Facade.cs  como AlunoFacade.cs são implementadas usando a palavra chave partial de forma que temos arquivos distintos mas que na verdade constituem um único arquivo.

Vejamos então o código de cada uma destas classes.

O arquivo FactoryDAO.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Macoratti.DAL;
namespace Macoratti.BLL
{
  public static class FactoryDAO
  {
      public static AlunoDAL CreateAlunoDAL()
      {
          return new AlunoDAL();
      }
  }
}

O padrão Factory fornece uma interface para a criação de famílias de objetos correlatos ou dependentes sem a necessidade de especificar a classe concreta destes objetos.

A classe FactoryDAO como o nome sugere é uma fabrica de instâncias para as classes concretas da camada de acesso a dados. No momento temos somente a classe AlunoDAL(), mas poderíamos ter muitas outras classes.

O arquivo Facade.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Macoratti.DAL;

namespace Macoratti.BLL
{
 public partial class Facade
 {
     private AlunoDAL _alunoDAL;

     public Facade()
     {
         _alunoDAL = FactoryDAO.CreateAlunoDAL();
     } 
 }
}

 

A classe Facade usa o padrão do mesmo nome para agrupar as chamadas que serão feitas a camada de acesso a dados via camada de negócios.

Em padrões de projeto, um façade (fachada em francês) é um objeto que disponibiliza uma interface para uma grande quantidade de funcionalidades de uma API, por exemplo. Um façade pode:
  • tornar uma  biblioteca de software mais fácil de entender e usar;
  • tornar o código que utiliza esta biblioteca mais fácil de entender;
  • reduzir as dependências em relação às características internas de uma biblioteca, trazendo flexibilidade no desenvolvimento do sistema;
  • envolver uma interface mal desenhada, com uma interface melhor definida.

O arquivo AlunoFacade.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Macoratti.DAL;
using Macoratti.Entidades;

namespace Macoratti.BLL
{
    public partial class Facade
    {
        public void InserirAluno(Aluno aluno)
        {
           this._alunoDAL.Insert(aluno);
        }
        
        public void UpdateAluno(int id, Aluno aluno)
        {
            this._alunoDAL.Update<int>(id, aluno);
        }

        public Aluno GetAluno(int id)
        {
            return this._alunoDAL.Get<int>(id);
        }

        public List<Aluno> GetTopAluno()
        {
            return this._alunoDAL.GetTop();
        }

       public void DeleteAluno(int id)
       {
           this._alunoDAL.Delete<int>(id);
       }
    }
}

Usando o conceito de partial class você pode dividir a definição de sua classe em mais de um arquivo físico.

O arquivo AlunoFacade.cs na verdade representa a mesma classe Facade. A separação é possível pelo uso da palavra chave partial. Embora tenhamos definidos os métodos para inserir, atualizar, excluir e obter um aluno somente o método GetTopAluno() será usado para obter as informações da tabela alunos a partir do método GetTop() da camada de acesso a dados.

Agora já temos tudo pronto só falta definir a camada de interface...

Criando a camada de interface

A camada de interface com o usuário será uma aplicação ASP .NET e estará no projeto EscolaWeb representado pelo arquivo Default.aspx.

Abra o arquivo Default.aspx e inclua um controle GridView. A seguir defina o seguinte código no code-behind Default.aspx.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Macoratti.BLL;
using Macoratti.Entidades;

namespace Escolaweb
{
    public partial class _Default : System.Web.UI.Page
    {
        //cria a instância da classe Facade 
        Facade _alunoFacade = new Facade();

        protected void Page_Load(object sender, EventArgs e)
        {
            //usa o método GetTopAluno() da camada de negócios para acessar a tabela alunos
            //e retornar as informações como uma lista de objetos 
            //exibindo-os no GridView
            GridView1.DataSource = _alunoFacade.GetTopAluno().ToList();
            GridView1.DataBind();
        }
    }
}

 

No código acima criamos uma instância da classe Facade e em seguida no evento Load da página web chamamos o método GetTopAluno() definido na camada de negócios este método por sua vez chama o método GetTop() da camada de acesso a dados que retorna uma lista de objetos alunos.

Abaixo temos um esquema que mostra a hierarquia de chamadas realizadas entre as camadas:

Antes de executar o projeto não esqueça de definir o projeto EscolaWeb como Set As Startup Project e a página Default.aspx como Set As Startup Page.

Feito isso basta rodar a solução que iremos obter o seguinte resultado:

Pegue o projeto completo aqui: EscolawebPostgreSQL.zip

Eu sei é apenas ASP .NET com boas práticas e padrões de projeto, mas eu gosto...

Referências:

José Carlos Macoratti