ASP

.NET MVC - CRUD com

Fluent NHibernate - I

Neste artigo vou mostrar como realizar as operações CRUD em

uma aplicação ASP .NET MVC usando o NHibernate e
realizando o mapeamento com o Fluent NHibernate.

Na seção NHibernate - Macoratti.net você vai encontrar muitos artigos que eu já escrevi mostrando como usar os
recursos do NHibernate.

Se você já chegou a usar o NHibernate e não conhece o Fluent NHibernate, deve saber que gerar os arquivos de
mapeamento (.hbm) dá muito trabalho e é uma tarefa que esta sujeita a erros.

Assim, se esse era um quesito que o desmotivava a usar o NHibernate, fique sabendo que agora você não tem mais
essa desculpa.

O Fluent NHibernate chegou (a um bom tempo por sinal) para auxiliar a realização dos mapeamentos das suas
entidades com o seu banco de dados. Com ele podemos realizar o mapeamento via código sem ter que usar os
arquivos .hbm.
Dessa forma o Fluent NHibernate oferece uma alternativa aos arquivos de mapeamento XML padrão do
NHibernate. Ao invés de escrever documentos XML (arquivos .hbm.xml), o Fluent NHibernate permite que você
escreva mapeamentos fortemente tipados usando código C# ou VB .NET.

Isso permite um fácil refatoramento, melhora a legibilidade e o código fica mais conciso.

Apenas para comparar veja abaixo um exemplo de um arquivo de mapeamento .hbm gerado, e, sua contrapartida
usando o Fluent NHibernate:

(fonte: https://github.com/jagregory/fluent-nhibernate/wiki/Getting-started)
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping
xmlns="urn:nhibernate-mapping-2.2" public class CatMap : ClassMap<Cat>
namespace="QuickStart" {
assembly="QuickStart"> public CatMap()
<class name="Cat" table="Cat"> {
<id name="Id"> Id(x => x.Id);
<generator class="identity" /> Map(x => x.Name)
</id> .Length(16)
<property name="Name"> .Not.Nullable();
<column name="Name" length="16" not - Map(x => x.Sex);
null="true" /> References(x => x.Mate);
</property> HasMany(x => x.Kittens);
<property name="Sex" /> }
<many-to-one name="Mate" /> }
<bag name="Kittens">
<key column="mother_id" />
<one-to-many class="Cat" />
</bag>
</class>
</hibernate-mapping>

Arquivo XML .hbm código Fluent NHibernate equivalente

O Fluent NHibernate pode ser baixado no seguinte link: http://www.fluentnhibernate.org/ ou se preferir via Nuget.

Neste artigo eu vou criar um projeto ASP .NET MVC (linguagem C#), e, usar o NHibernate e o Fluent NHibernate
para definir as classes POCO do mapeamento via código para criar as tabelas em tempo de execução no SQL Server
2012.

Recursos usados

 Visual Studio 2015 Community

 Linguagem C#
 NHibernate 4.0
 Fluent NHibernate
 SQL Server 2012 Express

Objetivos

 Usar os recursos do NHibernate e Fluent NHibernate realizar o CRUD em uma aplicação ASP .NET MVC

Aprendizado

 Realizar o CRUD em uma aplicação ASP .NET MVC usando a linguagem C#

  Criar um banco de dados SQL Server 2012 Express
 Criar as entidades que fazem partem do modelo
 Realizar o mapeamento ORM usando o Fluent NHibernate
 Criar a classe NHibernateHelper e definir a SessionFactory
 Criar o controlador, definir os métodos e criar as views para realizar o CRUD

Criando o projeto no VS Community

Abra o VS Community 2015 e clique em New Project;

A seguir selecione Visual C# -> Web -> ASP .NET Web Application;

Informe o nome CRUD_FluentNHibernate e clique no botão OK;

Selecione o template Empty e marque a opção MVC, sem autenticação, conforme figura a seguir:
Vamos agora incluir a referência no projeto ao NHibernate e ao Fluent NHibernate via Nuget.
No menu Tools clique em Nuget Manager Package e a seguir em Manage Nuget Packages for Solution;

Localize o pacote do FluentNhibernate e instale-o no projeto:

Ao final da operação teremos as referências ao NHibernate 4.0 e ao Fluent Nhibernate em nosso
projeto.

Definindo a fonte e o modelo de dados

Para este exemplo eu vou usar o banco de dados chamado Cadastro.mdf e a tabela Alunos que possui a
seguinte estrutura:
 USE [Cadastro]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Alunos](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Nome] [nvarchar](50) NOT NULL,
[Email] [nvarchar](100) NOT NULL,
[Curso] [nvarchar](50) NULL,
[Sexo] [nvarchar](50) NULL,
CONSTRAINT [PK_Alunos] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

Estrutura da Tabela Aluno Script SQL para gerar a tabela Alunos

Aproveite para incluir alguns dados na tabela alunos para efeito de testes.
Agora vamos criar na pasta Models do projeto a nossa classe de domínio que é uma classe POCO que
representa um aluno.

Clique com o botão direito sobre a pasta Models e a seguir em Add Class, informe nome Aluno e digite o
código abaixo para a classe Aluno:

public class Aluno

{
public virtual int Id { get; set; }
public virtual string Nome { get; set; }
public virtual string Email { get; set; }
public virtual string Curso { get; set; }
public virtual string Sexo { get; set; }
}

Vamos criar agora a nossa classe de mapeamento usando o FluentNHibernate que mapeará a nossa
classe de modelo(Aluno) para a tabela Alunos do banco dados.

Clique com o botão direito sobre a pasta Models e a seguir em Add Class, informe nome AlunoMap e
digite o código abaixo para a classe:
using FluentNHibernate.Mapping;
namespace Crud_FluentNHibernate.Models
{
class AlunoMap : ClassMap<Aluno>
{
public AlunoMap()
{
Id(x => x.Id);
Map(x => x.Nome);
Map(x => x.Email);
Map(x => x.Curso);
Map(x => x.Sexo);
Table("Alunos");
}
}
}

Neste código mapeamos as propriedades definidas na classe Aluno para os campos da tabela Alunos
definida na propriedade Table do Fluente NHibernate.

Usamos aqui as expressões lambdas que são funções podem conter expressões e declarações que são
usadas para criar delegates e árvores de expressões onde o tipo das variáveis não precisam ser declarados
visto que elas usam métodos anônimos.
Para saber mais sobre expressões lambdas veja o meu artigo: .NET - Expressões Lambdas

Vamos agora criar a classe NHibernateHelper que irá realizar a conexão com o banco de dados SQL
Server.

Clique com o botão direito sobre a pasta Models e a seguir em Add Class, informe nome
NHibernateHelper e digite o código abaixo para a classe:
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using NHibernate.Tool.hbm2ddl;
namespace Crud_FluentNHibernate.Models
{
public class NHibernateHelper
{
public static ISession OpenSession()
{
ISessionFactory sessionFactory = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(@"Data Source=(localDB)\v11.0;Initial Catalog=Cadastro;Integrated Security=True ")
.ShowSql()
)
.Mappings(m =>
m.FluentMappings
.AddFromAssemblyOf<Aluno>())
.ExposeConfiguration(cfg => new SchemaExport(cfg)
.Create(false, false))
.BuildSessionFactory();
return sessionFactory.OpenSession();
}
}
}
No código acima criamos o método OpenSession que será responsável por disponibilizar uma session que
representa o nosso contexto. Nesta classe temos a string de conexão com o banco de dados Cadastro.mdf
do SQL Server 2012.

ASP .NET MVC - CRUD

com Fluent NHibernate -
II

Neste artigo vou mostrar como realizar as operações CRUD em uma

aplicação ASP .NET MVC usando o NHibernate e realizando o
mapeamento com o Fluent NHibernate.

Na primeira parte do artigo criamos o projeto, definimos a fonte e o modelo de dados, realizamos o mapeamento

usando o Fluent NHibernate e criamos a classe NHibernateHelper para realizar a

conexão com o SQL Server.

Vamos agora definir o controlador e os métodos para realizar o CRUD no projeto ASP .NET MVC 5.

Recursos usados
  Visual Studio 2015 Community
 Linguagem C#
 NHibernate 4.0
 Fluent NHibernate
 SQL Server 2012 Express

Objetivos

 Usar os recursos do NHibernate e Fluent NHibernate realizar o CRUD em uma

aplicação ASP .NET MVC

Aprendizado

 Realizar o CRUD em uma aplicação ASP .NET MVC usando a linguagem C#

 Criar um banco de dados SQL Server 2012 Express
 Criar as entidades que fazem partem do modelo
 Realizar o mapeamento ORM usando o Fluent NHibernate
 Criar a classe NHibernateHelper e definir a SessionFactory
 Criar o controlador, definir os métodos e criar as views para realizar o CRUD

Definindo o controlador e realizando o CRUD

Agora resta criar o controlador na pasta Controllers e definir os métodos para realizar o CRUD.

Clique com o botão direito sobre a pasta Controllers e a seguir em Add -> Controller;

Selecione a opção MVC5 Controllers with read/write actions e clique em Add;

Informe o nome HomeController e clique no botão OK;

Teremos o controlador HomeController criado com o esqueleto dos métodos Index, Details, Create,
Edit, Delete.

Nossa próxima tarefa será definir cada um desses métodos. Vamos lá...

Após a criação de cada view eu vou fazer alguns ajustes traduzindo para o português alguns títulos e
cabeçalhos.

Antes de iniciar vamos declarar os seguintes namespaces no controlador HomeController:

using NHibernate;
using NHibernate.Linq;
using System.Linq;
using System.Web.Mvc;

1- Método Index - Exibir uma lista de alunos

Inclua o código abaixo no método Index() :
 public ActionResult Index()
{
using (ISession session = NHibernateHelper.OpenSession())
{
var alunos = session.Query<Aluno>().ToList();
return View(alunos);
}
}

Este método retorna uma lista de alunos a partir da tabela Alunos.

Para criar a respectiva view clique com o botão direito no interior do método selecione Add View;

Defina o template List e informe o Model class conforme a figura abaixo:

Será criada o arquivo Index.cshtml na pasta /Views/Home e o arquivo _Layout.cshtml na pasta
/Views/Shared.

Eu vou fazer alguns ajustes no arquivo de _Layout traduzindo alguns textos para o português.

Executando o projeto iremos obter o resultado abaixo para a view Index:

2- Método Details - Exibir detalhes de um aluno
Agora inclua o código abaixo no método Details:
 public ActionResult Details(int id)
{
using (ISession session = NHibernateHelper.OpenSession())
{
var aluno = session.Get<Aluno>(id);
return View(aluno);
}
}

Este método obtém as informações de um aluno.

Para criar a respectiva view clique com o botão direito no interior do método selecione Add View;

Defina o template Details e informe o Model class conforme a figura abaixo:

Será criada o arquivo Details.cshtml na pasta /Views/Home.

Executando o projeto iremos obter o resultado abaixo para a view Details:

3- Método Create - Incluir um novo Aluno
O método Create possui o GET e o POST.

Vamos incluir o código a seguir no método Create(POST):

 [HttpPost]
public ActionResult Create(Aluno aluno)
{
try
{
using (ISession session = NHibernateHelper.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(aluno);
transaction.Commit();
}
}
return RedirectToAction("Index");
}
catch
{
return View();
}
}

Este método inclui um novo aluno na tabela Alunos.

Para criar a respectiva view clique com o botão direito no interior do método selecione Add View;

Defina o template Create e informe o Model class conforme a figura abaixo:

Será criada o arquivo Create.cshtml na pasta /Views/Home.

Executando o projeto iremos obter o resultado abaixo para a view Create:

Após informar os dados e clicar no botão Criar Aluno teremos o aluno exibido na view Index():

4- Método Edit - Editar dados de um aluno

Para editar informações de um alunos precisamos definir o método para o GET e para o POST.

1- No método Edit(GET) inclua o código abaixo:

// GET: Home/Edit/5
public ActionResult Edit(int id)
{
using (ISession session = NHibernateHelper.OpenSession())
{
var aluno = session.Get<Aluno>(id);
return View(aluno);
}
}

Este método apresenta os dados que desejamos editar.

2- Após informar os dados a serem alterados precisamos definir o código do método Edit(POST) abaixo
que irá submeter e salvar as alterações:

// POST: Home/Edit/5
[HttpPost]
public ActionResult Edit(int id, Aluno aluno)
{
try
 {
using (ISession session = NHibernateHelper.OpenSession())
{
var alunoAlterado = session.Get<Aluno>(id);
alunoAlterado .Sexo = aluno.Sexo;
alunoAlterado .Curso = aluno.Curso;
alunoAlterado .Email = aluno.Email;
alunoAlterado .Nome = aluno.Nome;
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(alunoAlterado);
transaction.Commit();
}
}
return RedirectToAction("Index");
}
catch
{
return View();
}
}
Para criar a respectiva view clique com o botão direito no interior do método Edit(GET) selecione Add
View;

Defina o template Edit e informe o Model class conforme a figura abaixo:

Será criada o arquivo Edit.cshtml na pasta /Views/Home.

Executando o projeto iremos obter o resultado abaixo para a view Edit:

Após realizar as alterações veremos os dados alterado na view Index().

5- Método Delete - Deletar dados de um aluno

O método Delete também possui o GET que apresenta o aluno ao usuário.

Neste método inclua o código a seguir:

// GET: Home/Delete/5
public ActionResult Delete(int id)
{
using (ISession session = NHibernateHelper.OpenSession())
{
var aluno = session.Get<Aluno>(id);
return View(aluno);
}
}

Este código localiza o aluno pelo seu id e apresenta ao usuário para confirmar a exclusão.

Para excluir os dados temos que incluir o código abaixo no método Delete(POST) :
// POST: Home/Delete/5
[HttpPost]
public ActionResult Delete(int id, Aluno aluno)
{
try
{
using (ISession session = NHibernateHelper.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Delete(aluno);
transaction.Commit();
}
}
return RedirectToAction("Index");
}
catch
{
return View();
}
}
Para criar a respectiva view clique com o botão direito no interior do método Delete(GET) selecione Add
View;

Defina o template Delete e informe o Model class conforme a figura abaixo:

Será criada o arquivo Delete.cshtml na pasta /Views/Home.

Executando o projeto iremos obter o resultado abaixo para a view Delete:

Ao clicar no botão - Deletar aluno - o aluno será excluído da tabela Alunos.

Dessa forma acabamos de criar uma aplicação ASP .NET MVC realizando um CRUD básico com os recursos
do NHibernate e Fluent NHibernate.

Referências:
 Seção VB .NET do Site Macoratti.net
 Super DVD .NET - A sua porta de entrada na plataforma .NET
 Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#
 Super DVD C# - Recursos de aprendizagens e vídeo aulas para C#
 Seção C# do site Macoratti.net
 Seção ASP .NET do site Macoratti .net
 Curso Básico VB .NET - Vídeo Aulas
 Curso C# Básico - Vídeo Aulas
 Curso Fundamentos da Programação Orientada a Objetos com VB .NET
 Macoratti .net | Facebook
 macoratti - YouTube
 Jose C Macoratti (@macorati) | Twitter
 NHibernate - Macoratti.net
 .NET - Apresentando o padrão Repository - Macoratti.net
 VB .NET - Implementando o padrão Repository - Macoratti.net
 VB .NET - Usando o NHibernate - Macoratti.net
 NHibernate - Usando o ActiveRecord - Macoratti.net
 ASP .NET - Usando o NHibernate II - Macoratti.net

José Carlos Macoratti