ASP NET MVC + NHibernate + ExtJs – Parte 4

Vamos continuar a desenvolver o nosso pequeno sistema de contatos, hoje vamos criar o CRUD (Create, Retrieve, Update e Delete) que são as quatro operações básicas utilizadas no banco de dados (Insert, Select, Update e Delete).

Nessa parte do projeto vamos estar trabalhando com interfaces de repositórios, para a arquitetura do nosso sistema ficar um pouco mais organizado, no projeto Contatos.Business, clique com o botão direito em cima da pasta Repository e selecione a opção Add -> New Item, depois selecione Code -> Interface e coloque o nome de IRepositoryBase.

Adicione os seguintes métodos nessa interface.

[sourcecode language=”csharp”]
namespace Contatos.Business.Repository
{
public interface IRepositoryBase<T>
{
T Salvar(T entity);

T Alterar(T entity);

void Excluir(T entity);

T ObterPorId(int id);

IList<T> ObterTodos();

}
}
[/sourcecode]

Essa interface será a base para todas as nossas outras interfaces, como podemos ver ela contém as operações básicas e sempre recebe como parâmetro uma classe genérica T.

Antes de continuar temos que adicionar uma referência ao nosso projeto Contatos.Factory, clique com o botão direito em cima do projeto Contatos.Business e selecione a opção Add Reference, depois clique na aba Projects e selecione o projeto Contatos.Factory

Também temos que adicionar as referências paras as bibliotecas que vamos usar, siga os mesmos passos acima, porém selecione a aba Browse e navegue até a pasta Lib e adicione NHibernate.dll

Agora para cada entidade vamos criar uma interface de repositório herdando da nossa interface base. Dentro da pasta Repository crie as seguintes interfaces conforme abaixo.

IContatoRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Repository
{
public interface IContatoRepository : IRepositoryBase<Contato>
{
}
}
[/sourcecode]

IGrupoRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Repository
{
public interface IGrupoRepository : IRepositoryBase<Grupo>
{

}
}
[/sourcecode]

ITelefoneRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Repository
{
public interface ITelefoneRepository : IRepositoryBase<Telefone>
{
}
}

[/sourcecode]

ITipoTelefoneRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Repository
{
public interface ITipoTelefoneRepository : IRepositoryBase<TipoTelefone>
{

}
}
[/sourcecode]

Para quem não esta acustumado a trabalhar com interfaces pode achar essa solução um pouco confusa, mas depois vamos ver que vai nos ajudar bastante, veja que nesse primeiro momento não criamos nenhum método nas nossas interfaces, porque estamos herdando da nossa interface base que já tem os métodos básicos.

Agora vamos criar as classes que vão implementar essa interface, primeiramente vamos implementar a RepositoryBase, clique com o botão direito em cima da pasta Implementation e selecione a opção Add -> Class e coloque o nome de RepositoryBase.cs

RepositoryBase

[sourcecode language=”csharp”]
namespace Contatos.Business.Implementation
{
using System;
using System.Collections.Generic;
using Contatos.Business.Repository;
using NHibernate;
using NHibernate.Cfg;

public class RepositoryBase<T> : IRepositoryBase<T>
{
private static ISessionFactory _sessionFactory;

public static ISessionFactory SessionFactory
{
get
{
if (_sessionFactory == null)
{
var configuration = new Configuration();
configuration.Configure();
configuration.AddAssembly(typeof(T).Assembly);
_sessionFactory = configuration.BuildSessionFactory();
}
return _sessionFactory;
}
}

public void CloseSession()
{
if (!sessionFactory.IsClosed)
{
sessionFactory.Close();
sessionFactory.Dispose();
}
}

public T Salvar(T entity)
{
try
{
using (ISession session = SessionFactory.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(entity);
transaction.Commit();
}
}

return entity;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public T Alterar(T entity)
{
try
{
using (ISession session = SessionFactory.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(entity);
transaction.Commit();
}
}

return entity;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public void Excluir(T entity)
{
try
{
using (ISession session = SessionFactory.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Delete(entity);
transaction.Commit();
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public T ObterPorId(int id)
{
try
{
using (ISession session = SessionFactory.OpenSession())
{
return session.Get<T>(id);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public IList<T> ObterTodos()
{
IList<T> lista;

try
{
using (ISession session = SessionFactory.OpenSession())
{
lista = session.CreateCriteria(typeof (T)).List<T>();
}
return lista;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
}
[/sourcecode]

Essa classe é a base que contém os métodos seguintes métodos:

  • Salvar – Salva uma nova entidade no banco
  • Alterar – Altera uma entidade ja existente no banco
  • Excluir – Exclui uma entidade no banco
  • ObterPorId – Recupera uma entidade pelo código (PK)
  • ObterTodos – Recupera todas as entidades

Agora vamos criar as outras classes que vão herdar de RepositoryBase e implementar a sua interface

ContatoRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Implementation
{
using Contatos.Business.Repository;
using Contatos.Factory.Entity;

public class ContatoRepository : RepositoryBase<Contato>, IContatoRepository
{
}
}
[/sourcecode]

GrupoRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Implementation
{
using Contatos.Business.Repository;
using Contatos.Factory.Entity;

public class GrupoRepository : RepositoryBase<Grupo>, IGrupoRepository
{
}
}
[/sourcecode]

TelefoneRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Implementation
{
using Contatos.Business.Repository;
using Contatos.Factory.Entity;

public class TelefoneRepository : RepositoryBase<Telefone>, ITelefoneRepository
{
}
}

[/sourcecode]

TipoTelefoneRepository

[sourcecode language=”csharp”]
namespace Contatos.Business.Implementation
{
using Contatos.Business.Repository;
using Contatos.Factory.Entity;

public class TipoTelefoneRepository : RepositoryBase<TipoTelefone>, ITipoTelefoneRepository
{
}
}
[/sourcecode]

Nessa parte 4 criamos o CRUD, no próximo post vamos fazer os testes.

Download Parte 4

Até a próxima!

Sobre Leandro Prado

Leandro Silveira Prado é Premier Field Engineer na Microsoft especializado em Application Lifecycle Management.