en   |   pt

Junior Oliveira

NHibernate
  |       |     csharp  nhibernate  singleton    |     pt 

Olá pessoal, depois de um tempo parado, vamos falar um pouco de NHibernate.
Este post estava pronto a bastante tempo pode ser que alguma coisa não seja mais aplicado nas novas versão do NHibernate.

Instalando

A forma mais simples de instalar o NHibernate é usando o NuGet, abaixo o comando para instalar o NHibernate. No exemplo estou usando a versão 3.3.3.4000 para o .NET Framework 4.0.

1
install-package NHibernate

Configurando

Adicione um arquivo XML na solução chamado hibernate.cfg.xml.
Este arquivo irá conter as especificações de conexão a base de dados e outras configurações da conexão.
Abaixo segue uma configuração padrão para o banco MySQL e uma aplicação Web:

hibernate.cfg.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version='1.0' encoding='utf-8'?>
<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
<session-factory>
<property name="connection.provider">
NHibernate.Connection.DriverConnectionProvider, NHibernate
</property>
<property name="connection.connection_string_name">
ConnectionString
</property>
<property name="dialect">
NHibernate.Dialect.MySQLDialect
</property>
<property name="current_session_context_class">
web
</property>
</session-factory>
</hibernate-configuration>

Link com a lista de propriedades de configuração do NHibernate.

Domínio

O domínio abaixo é uma representação de uma conta de jogador, retirada do projeto Dolrath e adaptada para ficar mais didática.

Account.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Account : Entity<int> {
public virtual string Email { get; protected set; }
public virtual string Password { get; protected set; }
public virtual string Name { get; set; }
public virtual string Surname { get; set; }
protected Account() { }
public Account(string email, string password) {
Email = email;
Password = password;
}
public virtual void NewPassword() {
Password = Guid.NewGuid().ToString().Substring(0, 5);
}
}

Alguns pontos importantes ao notar o domínio é a presença do modificador virtual nos métodos e propriedades, este modificador possibilita o NHibernate criar um proxy sobre a nossa classe e que não existe nenhuma presença de infraestrutura de acesso a dados.

Mapeamento

O mapeamento abaixo esta escrito em XML, existem outras formas de mapeamento como por exemplo atributos ou por código usando NHibernate Fluent. Uma vantagens que eu vejo ao usar XML é que você não precisa recompilar a aplicação para alterar alguma regra no mapeamento e a forma de utilização ao meu ver é mais simples e didática.

Abaixo esta o mapeamento da nossa classe de domínio acima.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
assembly="Dolrath"
namespace="Dolrath.Domain.Entities">
<class name="Account" table="Accounts">
<id name="Id" type="Int32">
<generator class="hilo"/>
</id>
<property name="Email" type="string" length="100" not-null="true" />
<property name="Password" type="string" length="100" not-null="true" />
<property name="Name" type="string" length="100" not-null="false" />
<property name="Surname" type="string" length="100" not-null="false" />
</class>
</hibernate-mapping>

Uma das configurações mais importantes deste mapeamento é o gerador da chave primária, neste exemplo estou usando hilo, ele é usado para gerar a chave sem precisar ir até a base de dados não quebramos a Unit Of Work.

Click no elemento abaixo para maiores detalhes de seus atributos.

hibernate-mapping
class
id
property

Relações

Abaixo as duas formas de fazer uma relação de N para N (many-to-many).

bag: É usado quando temos uma situação onde a coleção pode haver valores duplicados.

1
2
3
4
5
6
7
8
9
10
11
<class name="Order" table="tbOrder">
<id name="Id" column="OrderId">
<generator class="identity"/>
</id>
<bag name="Items" inverse="true" cascade="all" access="field.camelcase-underscore">
<key column="OrderId" />
<one-to-many class="OrderItem" />
</bag>
</class>

set: É usado quando temos uma situação onde a coleção não pode haver valores duplicados.

1
2
3
4
5
6
7
8
9
10
11
<class name="Character" table="Characters">
<id name="Id" type="Int32">
<generator class="hilo"/>
</id>
<set name="Inventory" lazy="true" access="field.camelcase-underscore">
<key column="CharacterId"/>
<many-to-many class="Item" column="ItemId" />
</set>
</class>

Relação de N para 1 (many-to-one).

1
2
3
4
5
6
7
<class name="Character" table="Characters">
<id name="Id" type="Int32">
<generator class="hilo"/>
</id>
<many-to-one name="Account" unique="true" column="AccountId" />
</class>

Relação de 1 para 1 (one-to-one).

1
2
3
4
5
6
7
<class name="Account" table="Accounts">
<id name="Id" type="Int32">
<generator class="hilo"/>
</id>
<one-to-one name="Character" class="Character" cascade="all" />
</class>

Outras configurações

Discriminator

1
2
3
4
5
6
7
8
9
10
11
12
13
<class name="Character" table="Characters">
<id name="Id" type="Int32">
<generator class="hilo"/>
</id>
<discriminator column="Discriminator" not-null="true" type="string" />
<subclass name="Humano" discriminator-value="Humano"></subclass>
<subclass name="Elf" discriminator-value="Elf"></subclass>
<subclass name="Draconiano" discriminator-value="Draconiano"></subclass>
<subclass name="Metamorfo" discriminator-value="Metamorfo"></subclass>
</class>

Session Factory

A Session Factory é responsável por construir as sessões.
Quando uma aplicação é iniciada deve-se carregar todas as configurações do NHibernate e mapeamentos para criar a Session Factory, a criação da Session Factory é um processo demorado e deve ser feito apenas uma vez na aplicação.
O código abaixo é uma implementação do padrão Singleton e garante que a Session Factory será criada apenas uma vez na aplicação.

SessionFactoryFactory.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public sealed class SessionFactoryFactory {
private readonly ISessionFactory _sessionFactory;
public ISessionFactory CurrentSessionFactory { get { return _sessionFactory; } }
private static volatile SessionFactoryFactory _instance;
private static readonly object SyncRoot = new Object();
private SessionFactoryFactory() {
var cfg = new Configuration();
cfg.Configure();
cfg.AddAssembly(typeof(SessionFactoryFactory).Assembly);
_sessionFactory = cfg.BuildSessionFactory();
}
public static SessionFactoryFactory Instance {
get {
if (_instance == null) {
lock (SyncRoot) {
if (_instance == null)
_instance = new SessionFactoryFactory();
}
}
return _instance;
}
}
}

Action Filter - Transaction Per Request

Exitem várias formas de criar uma session em uma aplicação web a forma que irei adotar é bem comum, ela cria uma session por cada requisição feita.

Simplesmente vamos criar um action filter que irá interceptar a “entrada” e a “saída” da nossa action da controller.

Na entrada vamos pegar a session usando o contêiner de dependência e iniciar uma transação setando o nível de isolamento da mesma.
Lista dos níveis de isolamentos.

Na saída vamos verificar se houve um erro na requisição. Caso não houve um erro a transação será feito um commit da transação, senão será feito um rollback na mesma.

No final a Session será destruída.

TransactionPerRequestAttribute.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class TransactionPerRequestAttribute : ActionFilterAttribute {
private readonly IsolationLevel _isolationLevel;
private ISession _session;
private ITransaction _transaction;
public TransactionPerRequestAttribute(IsolationLevel isolationLevel = IsolationLevel.ReadUncommitted) {
_isolationLevel = isolationLevel;
}
public override void OnActionExecuting(ActionExecutingContext filterContext) {
_session = IoCContainer.Get<ISession>();
_transaction = _session.BeginTransaction(_isolationLevel);
}
public override void OnActionExecuted(ActionExecutedContext filterContext) {
if (filterContext.Exception == null)
_transaction.Commit();
else
_transaction.Rollback();
}
}

Action Filter - NHibernate Session

Este actino filter será utilizado para poder acoplar e desacoplar a session do NHibernate no contexto atual, para ficar mais simples a utilização vamos registrar ele no global filter assim não precisamos decorar a nossa action com esta anotação.

FilterConfig.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class FilterConfig {
public static void RegisterGlobalFilters(GlobalFilterCollection filters) {
filters.Add(new HandleErrorAttribute());
filters.Add(new NHibernateSessionAttribute());
}
}
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class NHibernateSessionAttribute : ActionFilterAttribute {
public override void OnActionExecuting(ActionExecutingContext filterContext) {
if (!CurrentSessionContext.HasBind(SessionFactoryFactory.Instance.CurrentSessionFactory)) {
CurrentSessionContext.Bind(IoCContainer.Get<ISession>());
}
}
public override void OnActionExecuted(ActionExecutedContext filterContext) {
var currentSession = CurrentSessionContext.Unbind(SessionFactoryFactory.Instance.CurrentSessionFactory);
if (currentSession == null) return;
currentSession.Close();
currentSession.Dispose();
}
}

Controller

Notem que estou recebendo a session no construtor da controller, quem irá fornecer esta session será o contêiner de dependência.
A action create do método post esta decorada com a anotação TransactionPerRequest, isto indica que esta action terá um controle de transação.

AccountController.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class AccountController : BaseController {
private readonly ISession _session;
public AccountController(ISession session) {
_session = session;
}
[HttpGet]
public ActionResult Create() {
return View();
}
[HttpPost]
[TransactionPerRequest]
public ActionResult Create(CreateViewModel viewModel) {
if (!ModelState.IsValid) return Error("Existem campos para preencher.", View(viewModel));
var account = new Account(viewModel.Email, viewModel.Password);
_session.Save(account);
return Information("Sua conta foi criada com sucesso.", RedirectToAction("Index", "Home"));
}
}

Existem várias formas de buscar dados usando NHibernate segue alguns abaixo:

Criteria Queries

AccountGetByIdQuery.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class AccountGetByIdQuery : IQuery<Account> {
private readonly ISession _session;
public int Id { get; set; }
public AccountGetByIdQuery(ISession session) {
_session = session;
}
public Account GetResult() {
return _session.CreateCriteria<Account>()
.Add(Restrictions.Eq("Id", Id))
.UniqueResult<Account>();
}
}

QueryOver Queries

AccountGetByEmailQuery.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class AccountGetByEmailQuery : IQuery<Account> {
private readonly ISession _session;
public string Email { get; set; }
public AccountGetByEmailQuery(ISession session) {
_session = session;
}
public virtual Account GetResult() {
return _session.QueryOver<Account>()
.Where(c => c.Email == Email)
.SingleOrDefault<Account>();
}
}

Native SQL

ItemResultGetAllQuery.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ItemResultGetAllQuery : IQuery<IEnumerable<ItemResult>> {
private readonly ISession _session;
public ItemResultGetAllQuery(ISession session) {
_session = session;
}
public IEnumerable<ItemResult> GetResult() {
return _session.CreateSQLQuery("SELECT Id, Name, Type FROM Items")
.SetResultTransformer(Transformers.AliasToBean<ItemResult>())
.List<ItemResult>();
}
}

Obrigado pela visita e espero que tenha gostado, até a próxima.