Neste artigo vamos continuar o nosso exemplo anterior, criando a camada de negócios (BLL – Business Logic Layer).

O repositório é utilizado entre a camada DAL e a camada de negócios (BLL) em uma arquitetura em camadas. A camada de negócios é usada para se comunicar com o banco de dados através do Entity Data Model 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.

A responsabilidade da camada de negócios é fornecer métodos para o cliente usar na apresentação e persistência das informações. Então, vamos arregaçar as mangas e partir para o trabalho!

Para atender as requisições da camada de apresentação, temos que nos lembrar quais objetivos a nossa aplicação vai cumprir e quais funcionalidades ela vai possuir. Ela deverá manter empregados e departamentos realizando as operações CRUD – incluindo, alterando, excluindo e consultando dados. Para isso, vamos criar um cadastro de empregados, de departamentos e um módulo de consulta onde iremos exibir os empregados por departamento.

No primeiro artigo, nós geramos o nosso Entity Data Model, onde obtivemos as entidades Departamento e Empregado.

Dessa forma, como já temos o nosso repositório criado, vamos definir na camada DAL as interfaces para representar os repositórios específicos para as entidades Empregado e Departamento.

Então selecione o projeto DAL e no menu PROJECT clique em Add New Item. Selecione o template Interface, informe o nome IEmpregadoRepositorio.cs e clique no botão Add. Em seguida, defina o código a seguir para a interface IEmpregadoRepositorio:

using Model;
namespace DAL
{
    public interface IEmpregadoRepositorio : IRepositorio<Empregado>
    {
    }
}

Repita o procedimento anterior e crie a interface IDepartamentoRepositorio.cs com o código mostrado abaixo:

using Model;
namespace DAL
{
    public interface IDepartamentoRepositorio : IRepositorio<Departamento>
    {
    }
}

Deveremos criar também as classes que implementam as interfaces IEmpregadoRepositorio e IDepartamentoRepositorio na camada DAL.

Então, selecione o projeto DAL e no menu PROJECT clique em Add New Item. Selecione o template Class, informe o nome EmpregadoRepositorio.cs e clique no botão Add. A seguir, defina o código a seguir para a classe EmpregadoRepositorio:

using Model;
namespace DAL
{
    public class EmpregadoRepositorio : Repositorio<Empregado>, IEmpregadoRepositorio
    {
    }
}

Repita o procedimento anterior e crie a classe DepartamentoRepositorio.cs com o código mostrado abaixo:

using Model;
namespace DAL
{
    public interface DepartamentoRepositorio : Repositorio<Departamento>, IDepartamentoRepositorio
    {
    }
}

Observe que não precisamos definir nenhum código nas interfaces e classes acima, pois estamos usando o mecanismo da herança e da implementação da interface e assim estamos usando os métodos definidos na interface IRepositorio e na classe Repositorio. Note também que estamos usando as entidades que foram separadas no projeto Model.

Neste momento, nossa solução tem a seguinte estrutura:

Vemos dois projetos: DAL e Model. Agora, sim, vamos incluir um novo projeto na solução que será a nossa camada de acesso a dados.

No menu FILE, clique em Add -> New Project.

A seguir, selecione o template Class Library e informe o nome BLL e clique no botão OK.

Remova o arquivo Class1 criado por padrão no projeto. Antes de prosseguir, vamos incluir referências aos projetos DAL e Model no projeto BLL.

Selecione o projeto BLL e no menu PROJECT clique em Add Reference.

A seguir, clique na guia Solution e marque as opções DAL e Model e clique no botão OK.

Agora vamos definir duas classes na camada BLL que irão implementar os métodos para atender as requisições da camada de apresentação relacionadas às entidadesEmpregado e Departamento.

Selecione o projeto BLL e no menu PROJECT clique em Add Class. Depois informe o nome EmpregadoBLL e clique no botão Add. A seguir, inclua o código abaixo na classe EmpregadoBLL:

using System.Collections.Generic;
using System.Linq;
using Model;
using DAL;
namespace BLL
{
    public class EmpregadoBLL
    {
        IEmpregadoRepositorio _empregadoRepositorio;
        public EmpregadoBLL()
        {
            //cria uma instância do repositorio Empregado
            _empregadoRepositorio = new EmpregadoRepositorio();
        }
        public List<Empregado> GetEmpregadosPorDepartamento(int departamentoId)
        {
            return _empregadoRepositorio.Get(e => e.DepartamentoId == departamentoId).ToList();
        }
        public List<Empregado> Get_EmpregadoInfo(int ID = -1)
        {
            if (ID == -1)
            {
                //retorna todos os Empregados
                return _empregadoRepositorio.GetTodos().ToList();
            }
            else
            {
                //retorna um determinado Empregado pelo seu ID
                return _empregadoRepositorio.Get(p => p.EmpregadoId == ID).ToList();
            }
        }
        public void AdicionarEmpregado(Empregado emp)
        {
            _empregadoRepositorio.Adicionar(emp);
            _empregadoRepositorio.Commit();
        }
        public Empregado Localizar(int id)
        {
            return _empregadoRepositorio.Find(id);
        }
        public void ExcluirEmpregado(Empregado emp)
        {
            _empregadoRepositorio.Deletar(c => c == emp);
            _empregadoRepositorio.Commit();
        }
        public void AlterarEmpregado(Empregado emp)
        {
            _empregadoRepositorio.Atualizar(emp);
            _empregadoRepositorio.Commit();
        }
    }
}

Na classe EmpregadoBLL, implementamos métodos para realizar as operações CRUD e selecionar dados usando o Repositorio criado na camada DAL. Eu não implementei um tratamento de exceção nesta classe, farei isso na classe DepartamentoBLL para mostrar como fazer e aí você implementa,ok?!

Vamos repetir o procedimento acima e criar a classe DepartamentoBLL e definir os métodos relacionados com a entidade Departamento.

Selecione o projeto BLL e no menu PROJECT clique em Add Class. Depois informe o nome DepartamentoBLL e clique no botão Add. A seguir, inclua o código abaixo na classe DepartamentoBLL:

using System.Collections.Generic;
using System.Linq;
using Model;
using DAL;
using System;
namespace BLL
{
    public class DepartamentoBLL
    {
        IDepartamentoRepositorio _departamentoRepositorio;
        public DepartamentoBLL()
        {
            try
            {
                //cria uma instância do repositorio departamento
                _departamentoRepositorio = new DepartamentoRepositorio();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public List<Departamento> Get_DepartamentoInfo(int ID = -1)
        {
            try
            {
                if (ID == -1)
                {
                    //retorna todos os departamentos
                    return _departamentoRepositorio.GetTodos().ToList();
                }
                else
                {
                    //retorna um determinado departamento pelo seu ID
                    return _departamentoRepositorio.Get(p => p.DepartamentoId == ID).ToList();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public void AdicionarDepartamento(Departamento dep)
        {
            try
            {
                _departamentoRepositorio.Adicionar(dep);
                _departamentoRepositorio.Commit();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public Departamento Localizar(int id)
        {
            try
            {
                return _departamentoRepositorio.Find(id);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public void ExcluirDepartamento(Departamento dep)
        {
            try
            {
                _departamentoRepositorio.Deletar(c => c == dep);
                _departamentoRepositorio.Commit();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public void AlterarDepartamento(Departamento dep)
        {
            try
            {
                _departamentoRepositorio.Atualizar(dep);
                _departamentoRepositorio.Commit();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}

Dessa forma já temos nossa camada de negócios (BLL) pronta para atender as requisições da camada de apresentação.

Na próxima parte do artigo vamos definir a nossa camada de apresentação.