.NET Core - Implementando o padrão Repositório - IV

  Hoje veremos como implementar o padrão repositório na plataforma .NET Core.

Continuando o artigo anterior vamos criar agora a camada de negócios (BLL).

O repositório é utilizado entre a camada de acesso a dados e a camada de negócios em uma arquitetura em camadas usando a abordagem clássica.

A camada de negócios é usada para se comunicar com o banco de dados através do contexto na camada de acesso a dados.

Assim quando a camada de apresentação requisitar ou enviar dados ela se comunica com a camada de negócios sem se importar como os dados são mantidos ou persistidos.

Abaixo vemos um esquema simplificado do fluxo e das dependências entre as camadas:

A responsabilidade da camada de negócios é fornecer métodos para o cliente usar na apresentação e persistência das informações.

Para atender as requisições da camada de apresentação temos que nos lembrar quais os objetivos a nossa aplicação vai cumprir e quais funcionalidades ela vai possuir.

Nossa aplicação deverá gerencias dados de clientes realizando as operações CRUD - Incluindo, alterando, excluindo e consultando dados.

Dessa forma como já temos o nosso repositório criado vamos definir na camada de negócio as interfaces para representar o repositório específico para a entidade Cliente.

Para isso temos que implementar um repositório para Clientes com base no repositório genérico criado. Vamos então criar uma interface IClienteRepository e a classe ClienteRepository que implementa esta interface.

Criando o projeto da camada de negócios

Vamos então incluir um novo projeto do tipo Class Library neste solução via menu File ->Add -> New Project;

Selecione o template Class Library(.NET Standard), informe o nome BusinessLogic e clique em OK;

Agora selecione o projeto e no menu PROJECT clique em Add New Item;

Selecione o template Interface, informe o nome IClienteRepository.cs e clique no botão Add;

A seguir defina o código a seguir para esta interface:

using DataAccess.Domain;
using DataAccess.Repository;
using System.Collections.Generic;
namespace BusinessLogic
{
    public interface IClienteRepository : IRepository<Cliente>
    {
        IEnumerable<Cliente> GetClientesPorNome();
    }
}

Observe que esta interface também herda da interface IRepository<T> onde T agora representa nossa entidade Cliente e que definimos um novo método para obter os clientes ordenados pelo nome.

Agora crie a classe ClienteRepository com o código a seguir:

using DataAccess.Context;
using DataAccess.Domain;
using DataAccess.Repository;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
namespace BusinessLogic
{
    public class ClienteRepository : IRepository<Cliente>, IClienteRepository
    {
        AppDbContext _context;
        public ClienteRepository(AppDbContext context)
        {
            _context = context;
        }
        public void Add(Cliente entity)
        {
            _context.Clientes.Add(entity);
        }
        public void Delete(Cliente entity)
        {
            _context.Clientes.Remove(entity);
        }
        public IEnumerable<Cliente> Get()
        {
            return _context.Clientes.ToList();
        }
        public void Update(Cliente entity)
        {
            _context.Clientes.Update(entity);
        }
        public IEnumerable<Cliente> Get(Expression<Func<Cliente, bool>> predicate)
        {
            return _context.Clientes.Where(predicate);
        }
        public Cliente GetById(Expression<Func<Cliente, bool>> predicate)
        {
            return _context.Clientes.FirstOrDefault(predicate);
        }
        public IEnumerable<Cliente> GetClientesPorNome()
        {
            return Get().OrderBy(c => c.Nome).ToList();
        }    
    }
}

Neste código implementamos os métodos do nosso repositório genérico para a entidade Cliente materializando assim as operações para poder realizar o CRUD nas informações de Clientes. Temos assim um repositório específico para Cliente.

Vamos criar a classe ClienteBusinessLogic que vai se comunicar com a camada de apresentação e com o repositório usando a Unit Of Work.

Crie a classe ClienteBusinessLogic com o código abaixo:

using DataAccess.Domain;
using DataAccess.Repository;
using System;
using System.Collections.Generic;
namespace BusinessLogic
{
    public class ClienteBusinessLogic : IDisposable
    {
        UnitOfWork _uow;
        public ClienteBusinessLogic(UnitOfWork uow)
        {
            _uow = uow;
        }
        public ClienteBusinessLogic()
        {
            _uow = new UnitOfWork();
        }
        public IEnumerable<Cliente> ListarClientes()
        {
            return _uow.ClienteRepository.Get();
        }
        public void AdicionarCliente(Cliente cli)
        {
            _uow.ClienteRepository.Add(cli);
            _uow.Commit();
        }
        public void ExcluirCliente(Cliente cli)
        {
            _uow.ClienteRepository.Delete(cli);
            _uow.Commit();
        }
        public void AlterarCliente(Cliente cli)
        {
            _uow.ClienteRepository.Update(cli);
            _uow.Commit();
        }
        public Cliente GetClientePorId(int codigo)
        {
            return _uow.ClienteRepository.GetById(c => c.ClienteId == codigo);
        }
        public void Dispose()
        {
            _uow.Dispose();
        }
    }
}

Observe que temos dois construtores, um onde injetamos uma instância da unit-of-work  e outro onde criamos uma instância da classe UnitOfWork.

A seguir criamos os métodos que usam os métodos do nosso repositório ClienteRepository via unit-of-work.

Temos assim tudo pronto e já podemos testar a nossa aplicação.

Na próxima parte do artigo vamos criar o projeto Console para testar a nossa implementação.

"E Jesus lhes respondeu: Meu Pai trabalha até agora, e eu trabalho também."
João 5:17

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti