Na primeira parte deste
artigo definimos o nosso
objetivo, os recursos que iríamos usar, criamos o banco de
dados e as tabelas no MySQL e no SQL Server, o projeto no SharpDevelop,
definimos as referências usadas no projeto, a classe
do nosso domínio e o arquivo de configuração para o
NHibernate. Hoje vamos
definir o arquivo de configuração da aplicação e realizar as
operações usando os recursos do NHibernate.

Definindo o
arquivo de
configuração da aplicação

Se você já criou aplicações na
plataforma .NET com acesso a dados usando DataSets ou DataReaders
deve estar familiarizado com o conceito de armazenar a string de
conexão em um arquivo de configuração App.Config ou
Web.Config.

Pois para o NHibernate
o conceito é
o mesmo. Você tem que definir em um arquivo de configuração
algumas informações que orientam o NHibernate quanto ao banco de
dados que está sendo usado, a string de conexão e outros
detalhes.

Como estamos trabalhando com uma
aplicação Windows Forms vamos criar um
arquivo app.config.

Com o projeto aberto no
SharpDevelop, no menu Projeto selecione -> Adicionar
Novo
Item;

Na janela Novo Arquivo selecione a
Categoria Misc e em Modelos selecione App.Config File e
clique
Criar:

A seguir defina no arquivo XML
criando o seguinte conteúdo:

 name="hibernate-configuration" 
type="NHibernate.Cfg.ConfigurationSectionHandler, NHibernate" />


 xmlns="urn:nhibernate-configuration-2.2">


 name="connection.provider">

NHibernate.Connection.DriverConnectionProvider

 name="connection.driver_class">
   


NHibernate.Driver.MySqlDataDriver

name="connection.connection_string">
 


Server=localhost;Database=alomundo;User ID=root;Password=gpxpst

 name="dialect">
 


NHibernate.Dialect.MySQLDialect

name="show_sql">
   false

name="hbm2ddl.keywords">
   none

 name="proxyfactory.factory_class">

NHibernate.ByteCode.Castle.ProxyFactoryFactory, 
NHibernate.ByteCode.Castle

Lembrando que esta configuração
vale para a versão 2.0 do NHiberante ou
superior.

O arquivo pode parecer complicado,
mas na verdade ele apenas define alguns parâmetros para a
aplicação, os quais são:

– – define o
provedor usado pelo NHibernate

NHibernate.Connection.DriverConnectionProvider

– – define o
driver usado para conexão com o banco de dados. Observe que
temos dois valores: um que está comentado e outro que está ativo.
Fizemos assim pois vamos usar dois banco de dados: o MySQL e o
SQL Server. Logo, para o banco de dados ativo usamos o driver
correspondente.

NHibernate.Driver.MySqlDataDriver

– –
define a string de conexão com o banco de dados. Novamente temos
dois valores – um para o SQL Server e outro para o MySQL.

Server=localhost;Database=alomundo;User
ID=root;Password=xxxxxx

– – Define
se os comandos SQL serão exibidos ou não.
false

–
Define o proxy usado pelo NHibernate
NHibernate.ByteCode.Castle.ProxyFactoryFactory,
NHibernate.ByteCode.Castle

O NHibernate usa este arquivo para saber como tratar com o banco
de dados e como usá-lo.

Como eu já mencionei, uma das grandes
vantagens do NHibernate é poder abstrair os comandos SQL e a
independência do banco de dados. Quando usamos ADO .NET temos
todo um trabalho relacionado com a definição de objetos para
conexão e persistência de dados, bem como dos comandos SQL
envolvidos.

Apenas para ilustrar, a figura abaixo
mostra uma comparação de um exemplo de arquitetura usando a ADO
.NET e o NHibernate.

Pois bem, se com o NHibernate eu não
tenho que escrever comandos SQL, como tenho que fazer para
realizar operações de persistência?

O NHibernate utiliza as interface
ISession, ITransaction e IQuery para realizar a
interação e a persistência com o banco de dados, portanto para
usar esses recursos do NHibernate temos que usar essas
interfaces. Onde:

• ISession – representa uma
  conexão com a sua base de dados;
• ITransacation – representa uma
  transação que o NHibernate controla;
• IQuery – representa uma
  consulta com a base de dados;

Vamos então definir uma aplicação
Windows Forms bem simples onde iremos
realizar operações de
consulta e persistência de dados usando esses recursos.

Vamos definir uma pequena
aplicação que realiza o controle de funcionários de uma
empresa. Nela iremos realizar as seguintes operações: Consultar
e exibir empregados, criar, atualizar e excluir empregados. Para
isso defini no formulário padrão da aplicação o seguinte
leiaute para a interface:

Controles usados :

• ListBox
• Button
• TextBox
• GroupBox

Todas as operações que iremos
realizar devem usar a interface ISession e abrir uma sessão a
partir da qual o NHibernate obtém as informações que definimos
nos arquivos de configuração. Nosso primeiro passo será
definir um método que usa a interface ISession. Eu vou fazer
isso no próprio formulário da aplicação e não em uma camada
separada como seria o correto, pois quero focar em mostrar como
usar esses recursos básicos do NHibernate e não estou
preocupado com as boas práticas neste momento.

Definindo o
código da
aplicação

Então no próprio formulário vamos
primeiro definir os namespaces que vamos usar na aplicação:

• using
  System;
• using System.Collections.Generic;
• using System.Drawing;
• using System.Windows.Forms;
• using NHibernate;
• using NHibernate.Cfg;
• using System.Reflection;
• using MySql.Data.MySqlClient;
• using MySql.Data;

A seguir vamos definir o método
estático OpenSession,que irá definir uma
sessão para o NHibernate conforme o código abaixo:

//define uma sessão
static ISession OpenSession()
{

if(factory == null)
	   {
		   try{
		      Configuration c = 
new Configuration();

c.AddAssembly(Assembly.GetCallingAssembly());
		      factory = 
c.BuildSessionFactory();
		    }
	   	    catch (Exception ex)

	   	    {
	   	    	 MessageBox.Show(" Erro : " + 
ex.Message.ToString());
	   	    	 Application.Exit();
	   	     }

              }
	   return factory.OpenSession();				      
}

O código deste método carrega as
informações dos arquivos hbml.xml definidos no projeto:

Configuration
c = new Configuration();
c.AddAssembly(Assembly.GetCallingAssembly());

e do arquivo App.Config da aplicação:

factory
= c.BuildSessionFactory();

criando uma sessão que será retornada e usada em nossa
aplicação:

return
factory.OpenSession();

Todas as operações que iremos
realizar vão usar esta sessão que foi criada.

Para começar vou mostrar como
acessar os dados dos empregados e exibi-los no formulário no
controle ListBox.

Isso é feito quando o usuário
clica no botão Exibir Empregados. O código associado ao evento
Click deste botão é o seguinte:

//exibe os empregados
void BtnExibirClick(object sender, 
EventArgs e)
{
using (ISession session = OpenSession())

	{
		try{
IQuery query = session.CreateQuery("from 
Empregado as emp order by emp.nome asc");

IList procuraEmpregados = 
query.List();
			lstEmpregados.Items.Clear();

lstEmpregados.Items.Add("Empregado(s) encontrado(s) : " + 
procuraEmpregados.Count);

			foreach( Empregado empregado in 
procuraEmpregados )

lstEmpregados.Items.Add(empregado.empregadoID());
		        }

catch (Exception ex)
	{
	      MessageBox.Show(" Erro : " + 
ex.Message.ToString());
	 }
     }			
}		

Neste código estamos usando a
linguagem de consulta do NHibernate chamada HQL-
Hibernate Query Language. Ela é parecida com a SQL, mas
é orientada a objetos e possui recursos de herança,
polimorfismo e associação.

Nota:
para mais detalhes sobre a HQL consulte o site oficial do
NHibernate: https://www.hibernate.org/hib_docs/nhibernate/html/queryhql.html

Primeiro obtemos a sessão que foi
criada e definimos a consulta para obter os empregados da
entidade Empregado que foi mapeada do banco
de dados.

IQuery query =
session.CreateQuery(“from Empregado as emp order by emp.nome
asc”);

Em seguida obtemos uma coleção dos
objetos Empregado:

IList
procuraEmpregados
= query.List();

Exibimos o total de
empregados encontrados:

lstEmpregados.Items.Add(“Empregado(s)
encontrado(s)
: ” + procuraEmpregados.Count);

Percorremos a coleção e exibimos o
ID e o nome do empregado no ListBox:

foreach(
Empregado empregado in procuraEmpregados )