[Fluent NHibernate]第一个程序

写在前面

在耗时两月，NHibernate系列出炉这篇文章中，很多园友说了Fluent Nhibernate的东东，也激起我的兴趣，想对它一探究竟，这里也将Fluent Nhibernate写成一个系列，记录自己的学习过程，关于这东东，也是第一次接触，也只能边摸索，边记录了。如果有描述错误的地方，还望多多包涵。

通过Nhibernate的学习，都觉得Nhibernate的使用映射文件的编写很麻烦，这里通过Fluent Nhibernate的进行对比学习。

Fluent Nhibernate简介

Fluent Nhibernate下载地址：http://www.fluentnhibernate.org/

在该网站上对Fluent Nhibernate的简介

Fluent, XML-less, compile safe, automated, convention-based mappings for NHibernate.

Fluent，更少的xml，编译安全，自动化，基于Nhibernate的映射。

Fluent NHibernate offers an alternative to NHibernate's standard XML mapping files. Rather than writing XML documents (.hbm.xml files), Fluent NHibernate lets you write mappings in strongly typed C# code. This allows for easy refactoring, improved readability and more concise code.

用编程的方式进行配置，让你能更好的理解，不需要编写复杂的映射文件，它能完全替换NHibernate的映射文件，让你在映射的时候能使用C#的强类型方式。

基本配置

测试项目结构

项目结构介绍

Wolfy.Data：项目数据层，存放操作数据库类，FluentNhibernateHelper

Wolfy.Domain：存放持久化类，及映射类。

Wolfy.UnitTest:单元测试项目

首先使用Nuget安装Fluent Nhibernate

安装成功后

Fluent Nhibernate是基于Nhibernate的，所以在安装Fluent Nhibernate的同时也会将Nhibernate的dll安装上。此时的Nhibernate的程序集的版本为

Fluent Nhibernate对应的Nhibernate版本为3.3.1.4000

编写FluentNhibernateHelper类

 using System;

 using System.Collections.Generic;

 using System.Linq;

 using System.Text;

 using System.Threading.Tasks;

 using NHibernate;

 using FluentNHibernate;

 namespace Wolfy.Data

 {

     /// <summary>

     /// Nhibernate辅助类

     /// </summary>

     public class FluentNHibernateHelper

     {

         private static ISessionFactory _sessionFactory;

         private static ISession _session;

         private static object _objLock = new object();

         private FluentNHibernateHelper()

         {

         }

         /// <summary>

         /// 创建ISessionFactory

         /// </summary>

         /// <returns></returns>

         public static ISessionFactory GetSessionFactory()

         {

             if (_sessionFactory == null)

             {

                 lock (_objLock)

                 {

                     if (_sessionFactory == null)

                     {

                         //配置ISessionFactory

                         _sessionFactory = FluentNHibernate.Cfg.Fluently.Configure()

                             //数据库配置

                 .Database(

                             //方言

                 FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2012

                             //连接字符串

                 .ConnectionString(

                      c => c.Server(".")

                     .Password("sa")

                     .Username("sa")

                     .Database("Shop")

                     .TrustedConnection()

                     )

                             //是否显示sql

                     .ShowSql()

                     )

                             //映射程序集

                     .Mappings(m => m.FluentMappings

                         .AddFromAssembly(System.Reflection.Assembly.Load("Wolfy.Domain"))

                         .ExportTo("c:\\"))

                     .BuildSessionFactory();

                     }

                 }

             }

             return _sessionFactory;

         }

         /// <summary>

         /// 重置Session

         /// </summary>

         /// <returns></returns>

         public static ISession ResetSession()

         {

             if (_session.IsOpen)

                 _session.Close();

             _session = _sessionFactory.OpenSession();

             return _session;

         }

         /// <summary>

         /// 打开ISession

         /// </summary>

         /// <returns></returns>

         public static ISession GetSession()

         {

              GetSessionFactory();

             if (_session == null)

             {

                 lock (_objLock)

                 {

                     if (_session == null)

                     {

                         _session = _sessionFactory.OpenSession();

                     }

                 }

             }

             return _session;

         }

     }

 }

CreateSessionFactory方法对应Nhibernate的配置文件，通过代码的方式指定Nhibernate的配置信息，使用起来更方便。下面为之前学习Nhibernate时写的配置文件，不明白的可以回到NHIbernate系列文章去查看。

 <?xml version="1.0" encoding="utf-8" ?>

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

     <session-factory>

     <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>

    <property name="connection.connection_string">

        server=.;database=shop;uid=sa;pwd=sa

   </property>

    <property name="dialect">NHibernate.Dialect.MsSql2008Dialect</property>

   <mapping  assembly="Wolfy.Shop.Domain"/>

   </session-factory>

   </hibernate-configuration>

一个例子

Customer持久化类

     /// <summary>

     /// 客户持久化类

     /// </summary>

     public class Customer

     {

         public virtual Guid CustomerID { set; get; }

         public virtual int Version { set; get; }

         public virtual string CustomerName { set; get; }

         public virtual string CustomerAddress { set; get; }

     }

添加映射类

CustomerMapping.cs

    /// <summary>

     /// Customer映射实体类，需要集成ClassMap泛型类

     /// </summary>

     public class CustomerMapping : ClassMap<Customer>

     {

         /// <summary>

         /// 映射关系实体类的构造函数

         /// 在构造函数中处理好映射关系

         /// </summary>

         public CustomerMapping()

         {

             //指定持久化类对应的数据表

             Table("TB_Customer");

             //自动增长的id

             //Id(i => i.CustomerID);

             //映射关系

             Id<Guid>("CustomerID").GeneratedBy.Guid();

             Map(m => m.CustomerAddress).Length().Nullable();

             Map(m => m.CustomerName).Length().Nullable();

             Map(m => m.Version);

         }

     }

映射配置类需继承ClassMap泛型类，在构造函数中可以通过Map方法，指定字段与数据表字段的对应关系，Map有两个重载方法，如下：

         //

         // 摘要:

         //     Create a property mapping.

         //

         // 参数:

         //   memberExpression:

         //     Property to map

         public PropertyPart Map(Expression<Func<T, object>> memberExpression);

         //

         // 摘要:

         //     Create a property mapping.

         //

         // 参数:

         //   memberExpression:

         //     Property to map

         //

         //   columnName:

         //     Property column name

         public PropertyPart Map(Expression<Func<T, object>> memberExpression, string columnName);

Map

这里有个需要注意的地方，如果不指定映射的数据表，默认持久化类要与数据库中的表名对应，比如持久化类名为Customer，而数据表名为TB_Customer，则有以下异常： could not execute batch command.[SQL: SQL not available]

意思就是对应关系找不到。解决办法就是指定映射的数据表名。

数据层CustomerData类添加AddCustomer方法

     /// <summary>

     /// 客户类数据层

     /// </summary>

     public class CustomerData

     {

         /// <summary>

         /// 添加客户对象

         /// </summary>

         /// <param name="customer"></param>

         /// <returns></returns>

         public bool AddCustomer(Customer customer)

         {

             ISession session = FluentNHibernateHelper.GetSession();

             using (var trans = session.BeginTransaction())

             {

                 try

                 {

                     session.SaveOrUpdate(customer);

                     session.Flush();

                     trans.Commit();

                     return true;

                 }

                 catch (Exception)

                 {

                     trans.Rollback();

                     return false;

                 }

             }

         }

     }

你会发现，方法与使用Nhibernate的时候的方法实现没什么区别，代码相同，唯一的区别就是配置文件的编写方式，一种是使用代码实现，一种是使用xml文件进行配置的。

单元测试

 using System;

 using Microsoft.VisualStudio.TestTools.UnitTesting;

 using Wolfy.Domain.Entities;

 using Wolfy.Data;

 namespace Wolfy.UnitTest

 {

     [TestClass]

     public class CustomerDataTest

     {

         private CustomerData _customerData;

         public CustomerDataTest()

         {

             _customerData = new CustomerData();

         }

         [TestMethod]

         public void AddCustomerTest()

         {

             var result = _customerData.AddCustomer(

                 new TB_Customer()

                 {

                     Version = ,

                     CustomerName = "wolfy",

                     CustomerAddress = "中国 北京",

                     CustomerID = Guid.NewGuid()

                 }

                 );

             Assert.IsTrue(result);

         }

     }

 }

描述：通过数据层的AddCustomer方法向数据库中添加一个客户对象，并获得添加结果，断言结果为true，则测试通过。
运行测试，测试结果

生成的sql语句

 exec sp_executesql N'INSERT INTO [TB_Customer]

 (CustomerAddress, CustomerName, Version, CustomerID)

 VALUES (@p0, @p1, @p2, @p3)',

 N'@p0 nvarchar(4000),

 @p1 nvarchar(4000),

 @p2 int,

 @p3 uniqueidentifier',

 @p0=N'中国 北京',

 @p1=N'wolfy',

 @p2=1,

 @p3='F15D04CF-300F-45C1-A774-3394CBA08155'

回头看一下，在FluentNhibernateHelper中，有这样一句代码：

                         //映射程序集

                     .Mappings(m => m.FluentMappings

                         .AddFromAssembly(System.Reflection.Assembly.Load("Wolfy.Domain"))

                         .ExportTo("c:\\"))

意思是将映射文件导出到c盘下，那么我们看一下c盘下生成了什么？

你会发现此时的xml文件正是Nhibernate中对应持久化类的映射文件，内容为：

 <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">

   <class xmlns="urn:nhibernate-mapping-2.2" name="Wolfy.Domain.Entities.Customer, Wolfy.Domain, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" table="TB_Customer">

     <id type="System.Guid, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

       <column name="CustomerID" />

       <generator class="guid" />

     </id>

     <property name="CustomerAddress" type="System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

       <column name="CustomerAddress" length="50" not-null="false" />

     </property>

     <property name="CustomerName" type="System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

       <column name="CustomerName" length="32" not-null="false" />

     </property>

     <property name="Version" type="System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

       <column name="Version" />

     </property>

   </class>

 </hibernate-mapping>

总结

关于Fluent Nhibernate的基本使用就介绍到这里，不管怎样，先让第一个程序跑起来，才算是走好了第一步。

本篇内容学习了如何使用Fluent Nhibernate生成配置文件及映射文件。

参考文章

http://www.cnblogs.com/inday/archive/2009/08/04/Study-Fluent-NHibernate-Start.html