Entity Framework 4.5: Criando uma aplica��o N-Tier com C#

Uma aplicaç�o n-tier nada mais � que uma aplicaç�o em camadas, no caso � uma aplicaç�o com n camadas. Esse tipo de aplicaç�o t�m in�meras vantagens, primeiramente porque voc� tem uma aplicaç�o bem dividida: uma camada para neg�cio, uma camada para acesso a dados e uma camada de interface com usu�rio. Voc� pode ter tamb�m uma camada espec�fica para os serviços, com isso a manutenç�o no sistema se torna bem mais simples, pois voc� pode realizar alteraç�es na camada de neg�cio sem interferir no funcionamento da camada de dados ou na de interface com os usu�rios. Novas implementaç�es ou at� mesmo uma troca de banco de dados se torna muito mais simples uma vez que somente alterando a camada de acesso a dados voc� j� teria outro banco funcionando com o restante da sua aplicaç�o.

O que s�o classes abstratas?

Classes abstratas s�o classes que somente podem ser herdadas e nunca instanciadas. Essas classes servem como modelos para suas classes derivadas. As classes que derivam da classe abstrata pode sobrescrever os m�todos implementados por ela caso seja necess�rio.

O que s�o interfaces?

S�o as interfaces que definem o que deve ser implementado pela classe, ou seja, � a interface que contem as assinaturas dos m�todos e propriedades que dever�o obrigatoriamente ser implementados pela classe.

Exemplo pr�tico

Vamos iniciar o nosso projeto abrindo o Visual Studio e criando um novo projeto clicando em File -> New -> Project. Veja a Figura 1.

Figura 1. Criando Novo Projeto

Na janela seguinte digite �empty� na caixa de pesquisa, selecione BlankSolution e altere a propriedade Name para SLNTIER ou para nome que preferir, conforme mostra a Figura 2.

Figura 2. Criando a Solution

Se olharmos no Solution Explorer veremos que foi criada uma soluç�o vazia, ent�o agora clique com o bot�o direito do mouse e escolha Add... e em seguida New Project. Selecione a opç�o Class Library e d� o nome de DAL (Data Access Layer) ou DAO(Data Acess Object), pois essa ser� nossa camada de acesso a dados. Veja os passos nas Figuras 3 e 4.

Figura 3. Adicionando um novo projeto

Figura 4. Class Library DAL

Para que o projeto fique com uma estrutura melhor, vamos criar uma pasta no projeto DAL e nomear como Interface. � nessa pasta que colocaremos todas as interfaces da classe Dal. Para isso, clique com o bot�o direito do mouse sobre o projeto DAL e escolha a opç�o Add-> New Item -> Folder, como � ilustrado na Figura 5.

Figura 5. Adicionando uma Pasta

Agora clique com o bot�o direito do mouse sobre a pasta que acabamos de criar e selecione Add -> New Item. Na janela que abrir� escolha a opç�o Interface e na propriedade Name coloque IBaseCrud. Essa ser� nossa Interface padr�o, ou seja, as demais Interfaces descender�o dela (Figuras 6 e 7).

Figura 6. Adicionando Interface

Figura 7. Interface IBaseCrud

Agora implemente o c�digo conforme a Listagem 1.

Listagem 1. Interface IBaseCrud


  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.Linq.Expressions;
   
  namespace DAL.Interface
  {
      public interface IBaseCrud<T>
      {
          void Add(T pEntity);
   
          void Delete(T pEntity);
   
          void Update(T pEntity);
   
          T Find(Expression<Func<T, bool>> where);
   
          IQueryable<T> GetAll();
   
          IQueryable<T> GetAll(Expression<Func<T, bool>> where);
   
          void SaveChanges(String Tipo);
      }
  }

Vamos entender o c�digo acima: na primeira linha colocamos <T>, o que significa que nossa classe � gen�rica, ou seja, qualquer tipo T poder� implement�-la - essa interface contem as assinaturas dos m�todos que nossas classes devem ter, nesse caso, por se tratar de uma interface para CRUD temos os m�todos padr�es Add, Update, Delete e SaveChanges, todos do tipo void. Al�m desses, temos ainda o m�todo Find e duas assinaturas para o m�todo GetAll, uma que recebe como par�metro uma express�o lambda e um m�todo sem par�metros � Find � que retorna um tipo T e os m�todos GetAll retornam um IQueryable<T>.

Agora clique sobre o projeto DAL e selecione Add-> New Item. Na janela que ir� se abrir selecione a opç�o Class e altere a propriedade Name para Abstract_Crud, conforme ilustrado nas Figuras 8 e 9.

Figura 8. Adicionando uma Classe

Figura 9. Classe Abstract_Crud

Agora implemente o c�digo conforme a Listagem 2.

Listagem 2. Implementando Abstract_Crud.


  using System;
  using System.Linq;
  using System.Linq.Expressions;
  using System.Data.Entity;
  using System.Collections.Generic;
  using System.Data.Objects;
  using System.Text;
  using DAL.Interface;
   
  namespace DAL
  {
      public abstract class Abstract_Crud<T> : IBaseCrud<T> where T : class
      {
          TutoriaisEntities _contexto = new TutoriaisEntities();
          private DbSet<T> _entidade;
   
          public Abstract_Crud()
          {
              _contexto.Configuration.LazyLoadingEnabled = true;
              _entidade = _contexto.Set<T>();
          }
   
          public void Add(T pEntity)
          {
              _entidade.Add(pEntity);
          }
   
          public void Delete(T pEntity)
          {
              _contexto.Entry<T>(pEntity).State = System.Data.EntityState.Deleted;
          }
   
          public void Update(T pEntity)
          {
              _contexto.Entry<T>(pEntity).State = System.Data.EntityState.Modified;
          }
   
          public T Find(Expression<Func<T, bool>> where)
          {
              return _entidade.Where(where).ToList().FirstOrDefault<T>();
          }
   
          public IQueryable<T> GetAll()
          {
              return _entidade;
          }
   
          public IQueryable<T> GetAll(Expression<Func<T, bool>> where)
          {
              return _entidade.Where(where);
          }
   
          public void SaveChanges(String Tipo)
          {
              _contexto.SaveChanges();
          }
      }
  }

Vamos entender o que foi implementado acima: a classe Abstract_Crud implementa a interface IBasedCrud que recebe um Tipo T, onde esse tipo T � obrigatoriamente uma classe. No construtor da classe setamos nosso contexto para lazyload true, por�m, deve se tomar muito cuidado ao ativar o lazyloading em alguns cen�rios, pois ele � muito bom, mas na maioria das vezes causa problemas de desempenho. Ap�s o construtor implementamos os m�todos b�sicos do CRUD, conforme definimos na Interface. Lembre-se que todos os m�todos da Interface devem ser obrigatoriamente implementados.

Temos um banco de dados com uma tabela Funcion�rio, e precisamos adicionar um Entity data Model ao Projeto DAL, conforme mostram as Figuras 10 a 14.

Figura 10. Adcionando um novo Item

Figura 11. Ado.Net Entity Data Model

Figura 12. Tipo do Modelo

Figura 13. Conex�o

Figura 14. Tabelas

Agora v� at� a pasta Interface no projeto DAL e clique com o bot�o direito do mouse e selecione Add-> new Item. Escolha a opç�o Interface e na Propriedade Name coloque IFuncionarios, conforme a Figura 15.

Figura 15. Interface IFuncionarios

Veja que conforme Listagem 3, a implementaç�o � bem simples: o que temos que fazer � herdar a interface IBaseCrud e passar como par�metro nossa Entidade FUNCIONARIO que est� no nosso Entity data Model. Caso deseje ter outros m�todos al�m dos j� criados, voc� pode colocar as suas assinaturas aqui.

Listagem 3. Entidade FUNCIONARIO


  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
   
  namespace DAL.Interface
  {
      public interface IFuncionarios : IBaseCrud<FUNCIONARIO>
      {
      }
  }

Adicione uma nova classe ao projeto DAL e altere a propriedade Name para Funcionarios. Nessa classe voc� deve herdar da Classe Abstract_Crud passando como par�metro a Entidade FUNCIONARIO. Implemente a Interface IFuncionario conforme a Listagem 4.

Listagem 4. Interface IFuncionario


  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using DAL.Interface;
   
  namespace DAL
  {
      public class Funcionarios : Abstract_Crud<FUNCIONARIO>, IFuncionarios
      {
      }
  }

Devido a nossa classe Funcionarios descender da Abstract_Crud, ela j� possui os m�todos Add, update Delete Find e GetAll, portanto, s� ser� necess�rio implementar m�todos que voc� tenha na sua Interface IFuncionarios.

Vamos � implementaç�o da camada de neg�cio ou BO (Business Object). Para isso, acesse o solution explorer e clique com o bot�o direito do mouse sobre a nossa solution e selecione Add New Project. Escolha a opç�o ClassLibrary e altere a propriedade Name para BO, conforme as Figuras 16 e 17.

Figura 16. Adicionando Novo Projeto

Figura 17. Class Library BO

Acesse o arquivo class1 e renomeie para FuncionarioBO. Faça a classe herdar a classe Funcionarios da camada DAL, conforme a Listagem 5. Nessa classe � que devemos implementar toda nossa regra de neg�cios. Apenas como exemplo, vamos implementar um m�todo count que retornar� a quantidade de registros na tabela.

Listagem 5. FuncionarioBO


  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using DAL;
   
  namespace BO
  {
      public class FuncionarosBO : Funcionarios
      {
          public int Count()
          {
              return this.GetAll().Count();
          }
      }
  }

Agora vamos criar nossa �ltima camada que � a UI (User Interface) ou apenas Interface. Acesse novamente o Solution Explorer, clique sobre a nossa soluç�o com o bot�o direito do mouse e selecione Add New Project. Agora selecione Windows Forms e altere a propriedade Name para UI e clique em Ok, conforme as Figuras 18 e 19.

Figura 18. Adicionando Projeto

Figura 19. Windows Form Application

Acesse a aba Tools e adicione um Panel. Nele adicione um Label, e no form adicione tamb�m um DataGridView. Altere a propriedades dos componentes conforme abaixo:

Propriedade/Objeto	Panel	Label	DataGridView
Name	pCima	lbRegistros	dgFunc
DOCK	TOP		Fill

Agora d� um duplo clique na barra de menu do form1 para que o Visual Studio v� para o Source e crie o m�todo load para o Form1. Nesse m�todo vamos implementar a chamada a classe BO para que possamos alimentar o Grid com os funcion�rios que est�o na tabela no Banco de Dados. Nesse mesmo m�todo tamb�m realizaremos a chamada do m�todo Count, que retorna a quantidade de duncion�rios da tabela. O c�digo deve ficar como o da Listagem 6.

Listagem 6. M�todo load


  using System;
  using System.Collections.Generic;
  using System.ComponentModel;
  using System.Data;
  using System.Drawing;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.Windows.Forms;
  using DAL;
  using BO;
   
  namespace UI
  {
      public partial class Form1 : Form
      {
          public Form1()
          {
              InitializeComponent();
          }
   
          private void Form1_Load(object sender, EventArgs e)
          {
              FuncionarosBO funcBO = new FuncionarosBO();
   
              dgFunc.DataSource = funcBO.GetAll().ToList();
   
              lbRegistros.Text = funcBO.Count().ToString();
          }
      }
  }

Abaixo segue a Figura 20 com o resultado fnal.

Figura 20. Resultado Final

Ficamos por aqui com mais um artigo, espero que tenha sido �til.

At� a pr�xima.

Criando uma aplica��o N-Tier com C#

Neste artigo veremos como criar uma aplicação N-Tier no C#. Vamos ver também como implementar essa aplicação utilizando classes abstratas, o que torna isso bem mais prático. Utilizaremos o Visual Studio 2012 e Entity Framework 4.5.

O que s�o classes abstratas?

O que s�o interfaces?

Exemplo pr�tico

Artigos relacionados