Entity Framework - Manutenção de dados com GridView em Camadas

Entity Framework 4 - Manutenção de dados com GridView em Camadas

Este é mais um artigo sobre o Entity Framework onde eu vou mostrar como realizar a manutenção de dados em uma aplicação ASP .NET usando os recursos do Entity Framework em sua nova versão disponibilizada com o Visual Studio 2010 em abril deste ano. A versão 4.

Se você não conhece o Entity Framework sugiro que leia os artigos do site na seção : Entity Framework

Neste artigo eu vou usar as boas práticas de programação e mostrar como criar uma camada de acesso a dados (DAL-Data Access Layer) com o Entity Framework 4.

Além disso vou criar a camada da lógica de negócios (BLL - Business Logic Layer) e a camada de apresentação (UI-User Interface) que será uma aplicação WEB bem simples onde iremos exibir os produtos por categoria e permitir ao usuário cadastrar e excluir produtos.

Os recursos usados neste artigo são:

Eu poderia usar o banco de dados Northwind.mdf ou qualquer outro banco de dados suportado pelo EF, mas para simplificar o nosso trabalho, vou criar um novo banco de dados no SQL Server Management Studio 2008 Express chamado Macoratti.mdf e criar neste banco duas tabelas : Categorias e Produtos com uma estrutura simplificada conforme exibido nas figuras 1.0 e 2.0 a seguir:

figura 1.0 - Tabela Categorias

figura 2.0 - Tabela Produtos

A tabela Categorias possui um relacionamento um-para-muitos com a tabela Produtos onde o campo categoriaid é a chave estrangeira.

Nota: O script de criação do banco de dados e das tabelas será anexado ao projeto.

Antes de arregaçar as mangas e por a mão na massa vou dar uma visão geral da aplicação.

Vamos criar uma solução no Visual Web Developer 2010 Express chamada EF_CRUD contendo 3 projetos:

BLL - (Business Logic Layer) responsável pela lógica do negócio - classes de negócio;
DAL - (Data Access Layer) responsável pelo acesso e persistência dos dados - interface e classes de acesso a dados usando o Entity Framework;
UI - (User Interface) responsável pela interface com o usuário - Aplicação WEB usando a tecnologia ASP .NET e a linguagem VB .NET;

A estrutura do projeto pode ser vista na figura abaixo:

Estrutura da aplicação exibindo uma solução e 3 projetos;

A camada de apresentação será composta pela página Index.aspx que irá apresentar os produtos cadastrados por categoria conforme a figura abaixo:

A interface permite exibir os produtos por categoria selecionada, cadastrar um novo projeto e excluir um produto existente.

Criando a solução e os projetos no VWD

Abra o Visual Web Developer 2010 Express Edition e no menu File -> New Project selecione Visual Basic -> Windows e a seguir o template Class Library e informe o nome DAL;

A seguir, no menu File -> Add -> New Project selecione Visual Basic -> Windows e a seguir o template Class Library e informe o nome BLL;

Finalmente no menu File -> Add -> New Project selecione Visual Basic -> Web e a seguir o template ASP. NET Empty Web Application e informe o nome WEB;

Terminando a tarefa veremos a janela Solution Explorer exibindo a solução e os 3 projetos:

Vamos fazer os seguintes ajustes :

Alterar o nome da solução para EF_CRUD;
Excluir as classes Class1.vb dos projetos;

Ao final deveremos ter o seguinte resultado:

Esse será o nosso ponto de partida e vamos iniciar definindo as classes da camada de acesso a dados DAL.

Criando a camada de acesso a dados (DAL) com o Entity Framework 4

Vamos iniciar definindo a camada de acesso a dados no projeto DAL. Vamos começar criando um Entity Data Model com base em nosso modelo de dados, o banco de dados Macoratti.mdf e as tabelas Categorias e Produtos;

Clique com o botão direito sobre o projeto DAL e selecione Add -> New Item;

A seguir selecione o template Data -> ADO .NET Entity Data Model , informe o nome Macoratti.edmx e clique no botão Add;

Na próxima janela do Assistente selecione o item - Generate from database e clique em Next>;

A seguir selecione a conexão com o banco de dados Macoratti.mdf e aceite o nome da entity connection como MacorattiEntities e clique em Next>;

Em seguida selecione as tabelas Categorias e Produtos, aceite o nome do Namespace como MacorattiModel e clique em Finish;

Ao final veremos as entidades criadas e o mapeamento ORM gerado pela ferramenta conforme a figura abaixo:

Vamos alterar o nome das entidades Categorias e Produtos alterando as propriedades Entity SetName e Name para Produto e Categoria respectivamente;

Ao final deveremos ter as entidades com o nome no singular conforme abaixo:

Agora vamos definir as classes que usará os métodos que foram criados no arquivo de contexto Macoratti.edmx.

Faremos isso definindo uma interface com os métodos padrões e a seguir iremos criar uma classe abstrata que implementa esta interface para depois criar classe concretas das entidades Categoria e Produto que herdam da classe abstrata. Vamos lá...

1- Criando a interface IBaseCrud que conterá as assinaturas dos principais métodos usados no projeto.

Clique com o botão direito sobre o projeto DAL e selecione Add -> New Item, e, a seguir selecione o template Code->Class e informe o nome IBaseCrud.vb e clique em Add;

Defina o código abaixo no arquivo IBaseCrud.vb:

Vamos entender o que foi feito !!!

Criamos uma interface, ou seja um contrato, onde definimos os métodos : Add, Delete,Update, Attach,Detach, Find, GetAll e SaveChanges que são os principais métodos que vamos usar em nossa aplicação;

Observe que a nossa interface é fortemente tipada onde estamos recebendo como parâmetro uma entidade (T).

Se você se lembra dos conceitos OOP uma interface é um contrato que deverá ser implementado por quem pretende usá-lo, e na interface definimos apenas as assinaturas dos métodos pois a implementação ficará a cargo do utilizador.

Agora vamos criar uma classe abstrata (uma classe abstrata não pode ser instanciada) onde iremos implementar a interface IBaseCrud definida acima.

Clique com o botão direito sobre o projeto DAL e selecione Add -> New Item, e, a seguir selecione o template Code->Class e informe o nome Abstract_Crud.vb e clique em Add;

A seguir defina o código a seguir no arquivo Abstract_Crud.vb :

Imports System.Linq
Imports System.Linq.Expressions

Namespace DAL

    Public MustInherit Class Abstract_Crud(Of T As Class)
                      Implements IBaseCrud(Of T)

        Private entidades As New MacorattiEntities()

        Public Sub Add(ByVal pEntity As T) Implements IBaseCrud(Of T).Add
            entidades.AddObject(pEntity.[GetType]().Name, pEntity)
        End Sub

        Public Sub Delete(ByVal pEntity As T) Implements IBaseCrud(Of T).Delete
            entidades.DeleteObject(pEntity)
        End Sub

        Public Function Find(ByVal where As System.Linq.Expressions.Expression(Of System.Func(Of T, Boolean))) As System.Linq.IQueryable(Of T) Implements IBaseCrud(Of T).Find
            Return entidades.CreateObjectSet(Of T)().Where(where)
        End Function

        Public Function GetAll() As System.Linq.IQueryable(Of T) Implements IBaseCrud(Of T).GetAll
            Return entidades.CreateObjectSet(Of T)()
        End Function

        Public Sub Update(ByVal pEntity As T) Implements IBaseCrud(Of T).Update
            entidades.ApplyCurrentValues(Of T)(pEntity.[GetType]().Name, pEntity)
        End Sub

        Public Sub SaveChanges() Implements IBaseCrud(Of T).SaveChanges
            entidades.SaveChanges()
        End Sub

        
      Public Sub Attach(ByVal pEntity As T) Implements IBaseCrud(Of T).Attach
            entidades.AttachTo(pEntity.[GetType]().Name, pEntity)
        End Sub

        Public Sub Detach(ByVal pEntity As T) Implements IBaseCrud(Of T).Detach
            entidades.Detach(pEntity)
        End Sub

    End Class

End Namespace

Observe que a classe Abstract_Crud foi definida com o modificador MustInherit que indica que ela é uma classe abstrata no VB .NET.

Note que a classe deve receber uma entidade que é uma classe: Abstract_Crud(Of T As Class)

Note também que temos a palavra Implements e em seguida a nossa interface significando que estamos usando o contrato definido na interface e por isso tivemos que implementar os métodos definidos na interface;

Se porventura não tivéssemos implementado algum dos métodos da interface iríamos receber a mensagem conforme abaixo:

A nossa classe abstrata cria uma instância do nosso contexto definido pelo Entity Data Model no arquivo Macoratti.edmx : Private entidades As New MacorattiEntities()

Através dessa instância temos acesso aos métodos gerados no mapeamento e temos acesso aos recursos do Entity Framework que iremos usar na aplicação.

Agora vamos criar as classes relativas as nossas entidades Categoria e Produto começando pela entidade Categoria:

Clique com o botão direito sobre o projeto DAL e selecione Add -> New Item, e, a seguir selecione o template Code->Class e informe o nome Categoria_DAL.vb e clique em Add;

Defina o código a seguir no arquivo:

Namespace DAL

    Public Class Categoria_DAL
        Inherits Abstract_Crud(Of Categoria)

    End Class

End Namespace

Na classe Categoria_DAL notamos o modificador inherits que indica que esta classe herda da classe Abstract_Crud(Of Categoria). Com isso teremos acesso ao todos os métodos da classe Abstract_Crud.

Após isso clique com o botão direito sobre o projeto DAL e selecione Add -> New Item, e, a seguir selecione o template Code->Class e informe o nome Produto_DAL.vb e clique em Add;

Inclua o código abaixo no arquivo:

Namespace DAL
    Public Class Produto_DAL
          Inherits Abstract_Crud(Of Produto)

        Private entidades As New MacorattiEntities

        Public Function getProduto() As Produto
            Dim prod As New Produto
            Return prod
        End Function

        Public Function produtosCategoria(ByVal catid As Integer) As List(Of Produto)
            Dim produtos As List(Of Produto)
            Dim categoria = (From cat In entidades.Categoria Where cat.categoriaid = catid Select cat).First
            produtos = categoria.Produtos.ToList()
            Return produtos
        End Function

        Public Function procuraProdutoNome(ByVal nomeProduto As String) As List(Of Produto)
            Dim produtos = (From prod In entidades.Produto Where prod.produtonome = nomeProduto Select prod).ToList
            Return produtos
        End Function

    End Class
End Namespace

Na classe Categoria_DAL também temos o modificador inherits que indica que esta classe herda da classe Abstract_Crud(Of Categoria). Com isso teremos acesso ao todos os métodos da classe Abstract_Crud. Além disso criamos três novos métodos nesta classe que serão usados na aplicação:

getProduto() - retorna uma instância da entidade Produto;
produtosCategoria - retorna uma lista de produtos para um determinado código;
procuraProdutoNome - retorna uma lista de produtos para um determinado nome de produto;

Antes de encerrar esta parte note que temos o arquivo App.Config, e, se espiarmos o seu código iremos perceber a string de conexão definida e que será usada na aplicação. O nome da string de conexão é igual ao usado pelo nosso contexto: MacorattiEntities


</system.diagnostics>
  <connectionStrings>
    <add name="MacorattiEntities" connectionString="metadata=res://*/Macoratti.csdl|res://*/Macoratti.ssdl|res://*/Macoratti.msl;provider= _
System.Data.SqlClient;provider connection string=&quot;Data Source=.\SQLEXPRESS;Initial Catalog=Macoratti;Integrated Security=True; _
MultipleActiveResultSets=True&quot;" providerName="System.Data.EntityClient" />
  </connectionStrings>
</configuration>

Dessa forma concluímos a nossa camada de acesso a dados, e, no próximo artigo irei definir a camada de negócios (BLL) e a interface WEB.

Aguarde a continuação em: Entity Framework 4 - Manutenção de dados com GridView em Camadas - 2

Referências:

Seção Entity Framework do site

José Carlos Macoratti