Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

.NET Pragmático
desvendando a tecnologia, um acrônimo por vez

Início
Sobre

Primeiros passos com Fluent NHibernate

Acredito que não sou o único que ficou “mal-acostumado”; com a facilidade trazida pela tecnologia Linq to
SQL (L2S) que a Microsoft lançou no ano passado.

Infelizmente, há poucos meses a Microsoft anunciou baixinho que não iria mais desenvolver o mesmo L2S, e
recomendou que todos adotassem em seu lugar Entity Framework, que, se por um lado é uma plataforma mais
robusta, por outro lado é mais complexa, e, assim como L2S, atraiu muitas críticas de puristas que consideram
essa plataforma difícil de estender e testar via unit tests.

Isso fez com que muitas empresas, incluindo a que eu trabalho, começasse a ver quais alternativas existem
para O/RM, e de fato existe um produto no mercado que é livre e que já provou seu valor: NHibernate. Algo
me diz que 2009 vai ser o ano que NHibernate vai entrar de fato na caixa de ferramentas da maioria dos
desenvolvedores intermediários e avançados, ainda mais com o recente desenvolvimento da biblioteca
Linq2NHibernate (L2NH) e Fluent NHibernate, esse último uma forma de configurar NHibernate usando
código ao invés de arquivos XML.

Como nunca usei NHibernate nem L2NH, mas pretendo em muito breve, vou cobrir nesse artigo e nos
próximos os primeiros passos com essa plataforma. Meu plano é usar esse código como base para um
aplicativo ASP.NET MVC que também quero blogar aqui em forma de tutorial.

Pra dar uma visão melhor de onde quero chegar, o aplicativo que pretendo desenvolver é uma “Estante de
livros virtual”, que me permita cadastrar livros (titulo, autor, imagem de capa etc) manualmente ou através de
procura na Amazon, bem como marcar quais livros eu pretendo comprar, estou atualmente lendo e emprestei
para alguém. Numa segunda fase esse aplicativo deverá suportar diferentes usuários. Ainda que eu não
pretenta seguir práticas estritamente TDD, vou procurar criar unit tests para a maior parte do meu código.

Criando o modelo
Antes de mais nada vou iniciar uma solução nova, Bookshelf, com dois projetos: Bookshelf.Model e
Bookshelf.Tests. O primeiro vai conter classes do tipo POCO (Plain Old C# Object), que significa classes que
não têm qualquer conhecimento sobre qual plataforma é usada para armazenamento. Métodos como
book.Update() e book.Delete() não vão existir aqui. Isso é uma forma de seguir o princípio de
responsabilidade única, que mencionei num post anterior.

1 de 6 17/4/2010 14:15
Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

O modelo inicial é extremamente simples: uma única classe, Book (vou escrever o código em inglês, incluindo
nome de classes e comentários, pois vou compartilhá-lo com alguns colegas de trabalho noruegueses).

01 namespace Bookshelf.Model
02 {
03 public class Book
04 {
05 public int ID { get; private set; }
06 public string ISBN { get; set; }
07 public string Title { get; set; }
08 public string Author { get; set; }
09 public int ReleaseYear { get; set; }
10 }
11 }

O próximo passo é mapear esse modelo, ou seja, ensinar ao NHibernate a acessar essa classe e como a mesma
deverá ser representada no banco de dados. O NHibernate pode tanto mapear bancos de dados já existentes
quanto criar novos bancos de dados.

01 namespace Bookshelf.Model.Mapping
02 {
03 public class BookMap : ClassMap
04 {
05 public BookMap()
06 {
07 Id(x => x.ID);
08 Map(x => x.ISBN).CanNotBeNull();
09 Map(x => x.Title).CanNotBeNull();
10 Map(x => x.Author);
11 Map(x => x.ReleaseYear);
12 }
13 }
14 }

Como o nome diz, dá pra ver que a leitura desse código é bem fluente, e todos os métodos são encadeáveis,
podem ser colocados uns após os outros formando “frases”; ou uma DSL rudimentar. O único encadeamento
que fiz por enquanto foi ao usar CanNotBeNull() para os campos que não quero que sejam nulos. Para que
esse código compilasse, tive que adicionar duas referências: NHibernate.dll e FluentNHibernate.dll (todas
DLLs necessárias estão incluídas no código-fonte, no final do artigo).

2 de 6 17/4/2010 14:15
Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

Testando o mapeamento
Agora já podemos testar esse mapeamento, pra ver se funciona mesmo. No meu projeto Bookshelf.Tests vou
criar uma classe BookTests. Também vou precisar de uma classe FixtureBase que vai ser a base de todas
minhas classes para testes, vai conter o código a ser reutilizado.

Vou começar por adicionar algumas referências: nunit.framework.dll, NHibernate.dll, FluentNHibernate.dll e

FluentNHibernate.framework.dll. Nesse caso vou usar NUnit, mas qualquer outra biblioteca de testes poderia
ser usada.
01 namespace Bookshelf.UnitTests
02 {
03 public class FixtureBase where TModel : PersistenceModel, new()
04 {
05 protected SessionSource SessionSource { get; set; }
06 protected ISession Session { get; private set; }
07
08 [SetUp]
09 public void SetupSession()
10 {
11 var cfg = new SQLiteConfiguration()
12 .InMemory()
13 .ShowSql();
14 SessionSource = new SessionSource(cfg.ToProperties(), new TModel());
15 Session = SessionSource.CreateSession();
16 SessionSource.BuildSchema(Session);
17
18 Session.Flush();
19 Session.Clear();
20 }
21
22 [TearDown]
23 public void TearDown()
24 {
25 Session.Close();
26 Session.Dispose();
27 }
28 }
29 }

O mais interessante aqui é o método SetupSession(), no qual criamos um banco de dados SQLite que vai rodar
na memória apenas. Isso significa que os testes serão extremamente rápidos. Ao usarmos SQLite nos testes
não significa que nosso programa propriamente dito terá que usar SQLite também, se quisermos usar SQL
Server ou Oracle basta usarmos uma configuração diferente, seja via XML, seja usando a sintaxe fluente
parecida com a acima. O método ShowSql() fará que toda vez que um comando ao banco de dados seja
executado, o SQL será mostrado no console.

Session é equivalente ao DataContext no Linq2SQL, é o objeto usado para disparar comandos no

NHibernate.

Vamos agora dar uma olhada na nossa classe de teste:

01 namespace Bookshelf.UnitTests
02 {
03
04 public class BookTestModel : PersistenceModel
05 {
06 public TestModel()
07 {
08 addMappingsFromAssembly(typeof(BookMap).Assembly);

3 de 6 17/4/2010 14:15
Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

09 }
10 }
11
12 [TestFixture]
13 public class BookTests : FixtureBase
14 {
15 [Test]
16 public void Can_Insert_Books()
17 {
18 //Arrange
19 var book = new Book
20 {
21 ISBN = "123456",
22 Author = "Isaac Asimov",
23 Title = "Foundation Trilogy",
24 ReleaseYear = 1950
25 };
26
27 //Act
28 Session.Save(book);
29 Session.Flush();
30
31 //Assert
32 Session.Clear();
33 var dbBook = Session.Get(book.ID);
34 Assert.AreNotSame(book, dbBook);
35 Assert.AreEqual(book.ID, dbBook.ID);
36 Assert.AreEqual(book.Title, dbBook.Title);
37 Assert.AreEqual(book.ISBN, dbBook.ISBN);
38 Assert.AreEqual(book.ReleaseYear, dbBook.ReleaseYear);
39 }
40 }
41 }

Na verdade temos duas classes aqui: a primeira, BookTestModel, serve apenas para aplicar o mapeamento
que definimos em BookMap. Como a classe BookTests deriva de FixtureBase, o código de setup de
FixtureBase será executado para configurar nosso banco de dados de acordo com o mapeamento de
BookTestModel.

Finalmente, o teste insere um livro no banco de dados (lembrando que nesse caso é um banco de dados na
memória, mas poderia muito bem ser um físico), e depois busca o livro do banco de dados e compara as
propriedades. Assert.AreNotSame garante que não estamos nos referenciando ao mesmo livro na memória.

Hora de executar o teste!

Perfeito! Repare que os comandos SQL também foram impressos.

Se quiser testar o código você mesmo, baixe aqui.

Num próximo artigo, vamos começar a usar Linq2NHibernate para criar a aplicação MVC.

4 de 6 17/4/2010 14:15
Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

Essa entrada foi postada em domingo, janeiro 18th, 2009 às 22:31 sob a(s) categoria(s) NHibernate, Programação. Você pode
acompanhar as respostas desse post através do RSS 2.0feed. Você pode responder, ou rastrear de seu próprio site.

3 Respostas para “Primeiros passos com Fluent NHibernate”

1. Chan Disse:
04/02/2009 às 22:13

Tb estou começando com NHibernate, alias sua matéria me ajudou, não conhecia o Fluent, vc conhece
o Castle ActiveRecord ?
Será que vale apena usar ele no lugar do Fluent ?
Não conheço bem nem o Catle nem o fluent, vou ler mais sobre… pra entender, talvez minha pergunta
esteja até errada…

Até mais …

2. rodbv Disse:
05/02/2009 às 18:15

Fala Chan,

Eu nunca usei o Castle, mas já li a respeito. O NHibernate permite que você crie classes to tipo
ActiveRecord (ou seja, classes que permitam que vc execute comandos do tipo usuario.SalvaDados())
bem como classes “puras”(como a classe Book acima) que não possua qualquer conhecimento sobre o
banco de dados, delegando a tarefa de salvar coisas no banco de dados para repositórios. Então é legal
ter essas diferentes possibilidades com NHibernate.

3. Leonardo Disse:
09/09/2009 às 23:49

Fala Rodbv,

Estou começando a estudar agora NHibernate entre outras coisas, tem alguma dica? Caminho das
pedras.

no Aguardo,
Leonardo Moraes.

Deixe uma resposta

Nome (obrigatório)

E-mail (will not be published) (obrigatório)

Site

5 de 6 17/4/2010 14:15
Primeiros passos com Fluent NHibernate « .NET Pragmático http://rodbv.wordpress.com/2009/01/18/primeiros-passos-com-fluent-nhi...

Notificar-me os comentários mais recentes via e-mail.

Notifique-me de novos artigos por e-mail

Tópicos recentes
Ano novo, endereço novo
Em busca de uma arquitetura sólida – Parte 3
Um mês de TDD
Quatro livros sobre história dos computadores que todo programador deveria ler
Primeiros passos com Fluent NHibernate

janeiro 2009
S T Q Q S S D
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 30 31
mar »

Meta
Login
Posts RSS
RSS dos comentários
WordPress.com

Tema Contempt por Vault9.

Blog no WordPress.com.

6 de 6 17/4/2010 14:15