Neste artigo vamos conhecer as classes que são responsáveis pela base das demais classes responsáveis pela lógica de negócios, realizando a criação, atualização, exclusão e consulta dos registros, através dos objetos que representam as tabelas do banco (entidades), ou tratando os dados antes de executar as operações básicas.
Começaremos pela interface IRepositorioCLN:
************ IRepositorioCLN.cs ************
using System;
using System.Collections.Generic;
using System.Data.Objects.DataClasses;
using System.Linq.Expressions;
using HLMI.Cadastro.CES;
namespace HLMI.Cadastro.CLN
{
public interface IRepositorioCLN<T> where T : EntityObject
{
T VerRegistroPorCodigo(long codigo);
T Salvar(T registro);
bool Atualizar(T registro);
bool Excluir(T registro);
List<T> ListarTodos();
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression);
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2);
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3);
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4);
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4, Expression<Func<T, bool>> expression5);
List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4, Expression<Func<T, bool>> expression5, Expression<Func<T, bool>> expression6);
}
}
***************************************
O objetivo de uma interface é separar o nome do metodo da sua implementação, assim como um objeto pode ser referenciado através da sua interface. Quando uma classe que implementa uma interface for criada, podemos instanciar esta classe através da sua interface, ou criar métodos que tem como parâmetros uma interface, assim qualquer classe que a implemente pode ser utilizada neste parâmetro. Essa é uma característica da herança na programação orientada a objetos.
A classe a seguir implementa a interface que apresentamos, e ela é a classe base para manipularmos todas as entidades. É a classe BaseCLN:
*********** BaseCLN.cs ******************
using System.Collections.Generic;
using System.Data.Objects.DataClasses;
using HLMI.Cadastro.CAD;
using HLMI.Cadastro.CES;
using System.Linq.Expressions;
using System;
namespace HLMI.Cadastro.CLN
{
public class BaseCLN<T> : IRepositorioCLN<T> where T : EntityObject
{
public List<string> Mensagem { private set; get; }
public BaseCLN()
{
Mensagem = new List<string>();
}
public List<T> ListarTodos()
{
return new BaseCAD<T>().ListarTodos();
}
public T VerRegistroPorCodigo(long codigo)
{
return new BaseCAD<T>().VerRegistroPorCodigo(codigo);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression)
{
return new BaseCAD<T>().ListarPorExpressao(expression);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
{
return new BaseCAD<T>().ListarPorExpressao(expression1, expression2);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3)
{
return new BaseCAD<T>().ListarPorExpressao(expression1, expression2, expression3);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4)
{
return new BaseCAD<T>().ListarPorExpressao(expression1, expression2, expression3, expression4);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4, Expression<Func<T, bool>> expression5)
{
return new BaseCAD<T>().ListarPorExpressao(expression1, expression2, expression3, expression4, expression5);
}
public List<T> ListarPorExpressao(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2, Expression<Func<T, bool>> expression3, Expression<Func<T, bool>> expression4, Expression<Func<T, bool>> expression5, Expression<Func<T, bool>> expression6)
{
return new BaseCAD<T>().ListarPorExpressao(expression1, expression2, expression3, expression4, expression5, expression6);
}
public T Salvar(T registro)
{
try
{
registro = new BaseCAD<T>().Salvar(registro);
Mensagem.Add(“Salvo com sucesso.”);
}
catch (Exception ex)
{
Mensagem.Add(“Registro não efetuado. ” + ex.Message);
}
return registro;
}
public bool Atualizar(T registro)
{
var sucesso = new BaseCAD<T>().Atualizar(registro);
if (sucesso)
Mensagem.Add(“Salvo com sucesso.”);
else
Mensagem.Add(“Registro não realizado.”);
return sucesso;
}
public bool Excluir(T registro)
{
return new BaseCAD<T>().Excluir(registro);
}
}
}
***************************************
A classe BaseCLN permite realizar as principais operações com qualquer entidade do sistema. Por exemplo: se quero consultar uma entidade Cliente através do seu ID, podemos usar o método VerRegistroPorCodigo da seguinte forma:
BaseCLN<Cliente> base = new BaseCLN<Cliente>();
Cliente cliente = base.VerRegistroPorCodigo(1);
onde o valor 1 (um) é o valor do Id no registro que está no banco de dados, e o retorno é o objeto cliente preenchido com todos os artributos que retornaram do banco de dados.
Estas duas classes devem ser criadas no projeto HLMI.Cadastro.CAD, e podemos criar outras classes que herdam de BaseCLN para acesso aos dados das entidades. Por exemplo: caso eu queira criar uma consulta específica para Cliente, então devo criar a classe ClienteCLN (observe a nomenclatura) que herda de BaseCLN, da seguinte forma:
*********** ClienteCLN *******************
using System.Collections.Generic;
using System.Linq;
using HLMI.Cadastro.CES;
namespace HLMI.Cadastro.CLN
{
public class ClienteCLN : BaseCLN<Cliente>
{
public List<Cliente> VerRegistro(Cliente registro)
{
List<Cliente> consulta = this.ListarTodos();
if (registro.Id > 0)
{
consulta = consulta.Where(c => c.Id == registro.Id).ToList();
}
if (!string.IsNullOrEmpty(registro.NomeCliente))
{
consulta = consulta.Where(c => c.NomeCliente.Contains(registro.NomeCliente)).ToList();
}
if (!string.IsNullOrEmpty(registro.Endereco))
{
consulta = consulta.Where(c => c.Endereco.Contains(registro.Endereco)).ToList();
}
return consulta.ToList();
}
}
}
***************************************
O método VerRegistro é um método exclusivo da classe ClienteCLN, que auxilia na consulta ao cliente pelo nome ou pelo endereço, se estiverem preenchidos. Ou seja, em um formulário de consulta, este método retorna uma lista de acordo com os campos informados no formulário (digamos que sejam apenas dois: nome e endereço).
Podemos observar que as classes usadas para a camada de lógica de negócios (CLN) são similares às classes usadas na camada CAD, entretanto o desenvolvedor deve ter em mente que as classes da camada CAD devem ser usadas apenas para permitir a comunicação das demais camadas com o banco de dados, enquanto que a camada CLN fica responsável por conter as classes que tratam as informações que são recebidas ou exibidas na camada de interface do usuário (CIA).