最近准备学NHibernate,于是网上狂找，看来有不少文章，但仔细看就会明白，搞来搞去，其实就那么几篇大同小异的文章，但还是终于在我们的博客上找到篇好点的，就是下面那篇了，我也不明白是哪为高手写的了，因为转载的太多了，有点糊涂了，也许是张老三的作品吧，但不知道是没有把相关源码共享出来，还是我没有找到，对一个新手来说，就一些文字真的有点困难啊，何况下面的文章可能由于手误，还是某些原因，我是调试很久才调得出来，也许是我的NHibernate,和NUIT的版本跟原文的不同，我用的NHibernate 0.9.1.0,NUnit2.2。顺便把NUnit也学了，还是蛮不错的了。下面的文章也许是我有些修改的了，望给想学NHibernate的稍有补益。
http://www.cnblogs.com/Files/sifang2004/NHibernateTest.rar
NHibernate 博客园专题之一
（原文标题，本人尊重原作，故此保留，可以点击看到原文）
http://www.cnblogs.com/wxx/archive/2005/07/17/194337.html
（因为太麻烦，我下面对原文所做的修改，不会再有说明，也再次感谢本文原作的努力，随着我学习的深入，我也会不断修改下文）
1. Nhibernate简写为NHB;
2. 本文例子的开发平台为win2000xp+sp2, sql server2000, Nhibernate0.9.1.0;
3. 使用SQL Server自带的罗斯文商贸数据库(Northwind),中文版;
4. 本文例子是基于测试驱动开发（TDD）的，因此建议使用NUnit2.2和Log4Net (如果你不熟悉NUnit，不要紧啊，趁此机会学习点简单的应用)；
一 NHB简介
NHB是基于ms.net的O/R Mapping持久框架，它从基于Java的Hibernate项目移植而来。O/R Mapping就是把对象到映射关系数据库的记录，简单的说就是能实现把一个对象存储为数据表中的一条记录和由一条记录创建一个相应的对象，数据表中的数据就是对象的属性。
那么为什么要使用O/R Mapping？它与传统的DataSet/DataTable又有什么不同了？
首先是设计上的不同，当使用O/R Mapping时，更多的是从对象的角度来设计程序，而把数据(对象的属性)存储的细节放在后面, 可以完全采用面向对象(OO)的方式来设计，而在使用DataSet/DataTable时，它只是存放数据的对象，看起来更像一个数据表，不能直观的表达业务概念。
二 NHB中主要接口的介绍
ISession
ISession是面向用户的主要接口，主要用于对象持久化，数据加载等操作，支持数据库事务，它隐藏了NHB内部复杂的实现细节，ISession由ISessionFactory创建。
ISessionFactory
ISessionFactory是NHB内部的核心类，它维护到持久机制(数据库)的连接并对它们进行管理，同时还会保存所有持久对象的映射信息。
ISessionFactory由Configuration创建，因为创建ISessionFactory的开销非常大（需要加载映射信息），所以这个对象一般使用Singleton（单例）模式。
ITransaction
ITransaction是NHB的事务处理接口，它只是简单的封装了底层的数据库事务。
事务必须由ISession来启动。
ICriteria
ICriteria是Expression(表达式)数据加载接口，Expression是一个关系表达式组合，通过它能产生SQL语句的Where部分, 用户需要通过ISession来间接调用它。
IQuery
IQuery是HQL数据加载接口，HQL(Hibernate Query Language)是NHB专用的面向对象的数据查询语言，它与数据库的SQL有些类似，但功能更强大！同ICriteria一样，也需要通过ISession来间接调用它。
三 持久化操作
1. 会话和会话工厂
要进行持久化操作，必须先取得ISession和ISessionFactory，我们用一个Sessions类来封装它们， Sessions类的属性和方法都是静态的，它有一个Factory属性, 用于返回ISessionFactory, 有一个GetSession方法，用于取得一个新的ISession。
测试类代码如下:
using
System;
using
NUnit.Framework;
using
NHibernate;
namespace
NHibernateTest
{
///
///
SessionsFixture 的摘要说明。
///
///
[TestFixture]
public
class
SessionsFixture
{
public
SessionsFixture()
{
//
//
TODO: 在此处添加构造函数逻辑
//
}
[Test]
//
测试能否取得NHB会话工厂。
public
void
FactoryTest()
{
ISessionFactory sf
=
Sessions.Factory;
Assert.IsNotNull( sf,
"
get sessionfactory fail!
"
);
}
[Test]
//
测试能否取得NHB会话。
public
void
GetSessionTest()
{
ISession s
=
Sessions.GetSession();
Assert.IsNotNull( s,
"
get session fail!
"
);
}
}
}
现在还没写Sessions类，将不能通过编译! 下面我们来实现Sessions类.
using
System;
using
NHibernate;
using
System.Reflection;
namespace
NHibernateTest
{
///
///
Sessions 的摘要说明。
///
public
class
Sessions
{
private
static
readonly
object
lockObj
=
new
object
();
private
static
ISessionFactory _factory;
public
Sessions()
{
//
//
TODO: 在此处添加构造函数逻辑
//
}
public
static
ISessionFactory Factory
{
get
{
if
( _factory
==
null
)
{
lock
( lockObj )
{
if
( _factory
==
null
)
{
NHibernate.Cfg.Configuration cfg
=
new
NHibernate.Cfg.Configuration ();
cfg.AddAssembly( Assembly.GetExecutingAssembly() );
_factory
=
cfg.BuildSessionFactory();
}
}
}
return
_factory;
}
}
public
static
ISession GetSession()
{
return
Factory.OpenSession();
}
}
}
OK，现在编译可以通过了，启动NUnit并选择生成的文件NHibernateTest.exe,运行测试。我们得到了红色的条，出错了！原来还没有加入NHibernate的配置信息（当使用NHibernate时，需要在项目的配置文件中加入NHibernate的配置信息。关于配置信息，在下面有说明）。在项目的配置文件App.Config(如没有请自行创建一个)中加入以下内容.
稍做解释，下面的配置文件主要是配置了NHibernate和log4net，例如配置了NHibernate连接数据库的连接字符串；log4net把日志记到哪个文件中，本例就是"log.txt"。每次写日志向文件中追加，而不是重写
xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
configSections>
<nhibernate>
<add
key="hibernate.show_sql"
value="true"
/>
<add
key="hibernate.connection.provider"
value="NHibernate.Connection.DriverConnectionProvider"
/>
<add
key="hibernate.dialect"
value="NHibernate.Dialect.MsSql2000Dialect"
/>
<add
key="hibernate.connection.driver_class"
value="NHibernate.Driver.SqlClientDriver"
/>
<add
key="hibernate.connection.connection_string"
value="Server=127.0.0.1;initial catalog=Northwind;User id =golinjoe;Password=2525775"
/>
nhibernate>
<log4net>
<appender name="rollingFile" type="log4net.Appender.RollingFileAppender,log4net" >
<param name="File" value="log.txt" />
<param name="AppendToFile" value="true" />
<param name="RollingStyle" value="Date" />
<param name="DatePattern" value="yyyy.MM.dd" />
<param name="StaticLogFileName" value="true" />
<layout type="log4net.Layout.PatternLayout,log4net">
<param name="ConversionPattern" value="%d [%t] %-5p %c [%x] <%X{auth}> - %m%n" />
layout> appender> <root> <priority value="ALL" /> <appender-ref ref="rollingFile" /> root> log4net> configuration>
再次运行测试，就可以看见绿色的条了。
在取得会话工厂的代码中，我使用了如下代码：
if ( _factory == null ) {
lock ( lockObj ) {
if ( _factory == null ) {
// build sessionfactory code;
}
}
}
这是一个典型的double lock方式，用来产生线程安全的Singletion（单例）对象。
2. 基本CRUD操作
在很多介绍NHB的文章，包括NHB带的测试用例中，业务对象只是做为一个数据实体存在的，它没有任何操作！这在java中是比较典型的作法。
而我希望我们的业务对象自身就能完成基本的Create/Retrieve/Update/Delete，即CRUD操作，
在罗斯文商贸应用中，存在客户(customer)业务对象，先来为它建立一个测试用例,
using
System;
using
NHibernate;
using
NUnit.Framework;
namespace
NHibernateTest
{
///
///
CustomerFixture 的摘要说明。
///
[TestFixture]
public
class
CustomerFixture
{
public
CustomerFixture()
{}
[Test]
//
测试Customer对象的CRUD操作。
public
void
TestCRUD()
{
Customer c
=
new
Customer();
c.CustomerId
=
"
test
"
;
c.CompanyName
=
"
company name
"
;
c.ContactName
=
"
contact name
"
;
c.Address
=
"
address
"
;
c.Create();
//
测试 insert操作，
Customer c2
=
new
Customer( c.CustomerId );
//
测试 retrieve 操作.
Assert.AreEqual( c2.CompanyName,
"
company name
"
,
"
save companyname fail!
"
);
c2.CompanyName
=
"
update name
"
;
c2.Update();
//
测试 update 操作.
Customer c3
=
new
Customer( c.CustomerId );
Assert.AreEqual( c3.CompanyName,
"
update name
"
,
"
update companyname fail!
"
);
c3.Delete();
//
测试 delete 操作.
}
}
}
接下来创建Customer业务类：
using
System;
namespace
NHibernateTest
{
///
///
Customer 的摘要说明。
///
public
class
Customer : BizObject
{
public
Customer() { }
public
Customer(
string
existingId ) :
base
( existingId ) { }
#region
persistent properties.
private
string
_customerId
=
string
.Empty;
private
string
_companyName
=
string
.Empty;
private
string
_contactName
=
string
.Empty;
private
string
_contactTitle
=
string
.Empty;
private
string
_address
=
string
.Empty;
private
string
_city
=
string
.Empty;
private
string
_region
=
string
.Empty;
private
string
_postalCode
=
string
.Empty;
private
string
_country
=
string
.Empty;
private
string
_phone
=
string
.Empty;
private
string
_fax
=
string
.Empty;
public
string
CustomerId
{
get
{
return
_customerId; }
set
{ _customerId
=
value; }
}
public
string
CompanyName
{
get
{
return
_companyName; }
set
{ _companyName
=
value; }
}
public
string
ContactName
{
get
{
return
_contactName; }
set
{ _contactName
=
value; }
}
public
string
ContactTitle
{
get
{
return
_contactTitle; }
set
{ _contactTitle
=
value; }
}
public
string
Address
{
get
{
return
_address; }
set
{ _address
=
value; }
}
public
string
City
{
get
{
return
_city; }
set
{ _city
=
value; }
}
public
string
Region
{
get
{
return
_region; }
set
{ _region
=
value; }
}
public
string
PostalCode
{
get
{
return
_postalCode; }
set
{ _postalCode
=
value; }
}
public
string
Country
{
get
{
return
_country; }
set
{ _country
=
value; }
}
public
string
Phone
{
get
{
return
_phone; }
set
{ _phone
=
value; }
}
public
string
Fax
{
get
{
return
_fax; }
set
{ _fax
=
value; }
}
#endregion
}
}
在Customer类中，没有实现CRUD操作，这些操作在业务对象基类BizObject中实现，代码如下:
using
System;
namespace
NHibernateTest
{
///
///
BizObject 的摘要说明。
///
public
class
BizObject
{
public
BizObject() { }
public
BizObject(
object
existingId )
{
ObjectBroker.Load(
this
, existingId );
}
public
virtual
void
Create()
{
ObjectBroker.Create(
this
);
}
public
virtual
void
Update()
{
ObjectBroker.Update(
this
);
}
public
virtual
void
Delete()
{
ObjectBroker.Delete(
this
);
}
}
}
BizObject简单的将数据操作转发至ObjectBroker类, 目的是为了降低业务层和NHB之间的耦合, 以利于持久层间的移植。
using
System;
using
NHibernate;
using
NHibernateTest;
namespace
NHibernateTest
{
///
///
ObjectBroker 的摘要说明。
///
public
class
ObjectBroker
{
private
ObjectBroker() { }
public
static
void
Load(
object
obj,
object
id )
{
ISession s
=
Sessions.GetSession();
try
{
s.Load( obj, id );
}
finally
{
s.Close();
}
}
public
static
void
Create(
object
obj )
{
ISession s
=
Sessions.GetSession();
ITransaction trans
=
null
;
try
{
trans
=
s.BeginTransaction();
s.Save( obj );
trans.Commit();
}
finally
{
s.Close();
}
}
public
static
void
Update(
object
obj )
{
ISession s
=
Sessions.GetSession();
ITransaction trans
=
null
;
try
{
trans
=
s.BeginTransaction();
s.Update( obj );
trans.Commit();
}
finally
{
s.Close();
}
}
public
static
void
Delete(
object
obj )
{
ISession s
=
Sessions.GetSession();
ITransaction trans
=
null
;
try
{
trans
=
s.BeginTransaction();
s.Delete( obj );
trans.Commit();
}
finally
{
s.Close();
}
}
}
}
ObjectBroker对ISession进行了必要的封装，通过ISession,就可以简单的完成对象的CRUD操作了。
编译并运行测试，CustomerFixture的TestCRUD操作还是不能通过! 异常信息为:
NHibernateTest.CustomerFixture.TestCRUD : NHibernate.MappingException : Unknown entity class: NHibernateTest.Customer
显然，是因为我们还没有为Customer对象编写映射文件，而导致NHB不能对Customer对象进行持久化操作。
Customer对象的映射文件(Customer.hbm.xml)内容如下:
xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0">
<class name="NHibernateTest.Customer,NHibernateTest" table="Customers">
<id name="CustomerId" column="customerId" type="String" unsaved-value="">
<generator class="assigned"/>
id>
<property name="CompanyName" column="companyName" type="String" />
<property name="ContactName" column="contactName" type="String" />
<property name="ContactTitle" column="contactTitle" type="String" />
<property name="Address" column="address" type="String" />
<property name="City" column="city" type="String" />
<property name="Region" column="region" type="String" />
<property name="PostalCode" column="postalCode" type="String" />
<property name="Country" column="country" type="String" />
<property name="Phone" column="phone" type="String" />
<property name="Fax" column="fax" type="String" />
class>
hibernate-mapping>
这个映射文件算是NHB中较为简单的了。
class的name指定业务对象全名及其所在程序集，table指定数据表的名称；
id用于指定一个对象标识符（数据表中的主键）及其产生的方式, 常用的主健产生方式有自增型(identity)和赋值型(assigned)，这里使用了assigned，需要注意的是unsaved-value属性，它指定对象没有持久化时的Id值，主要用于SaveOrUpdate操作；
property用于指定其它映射的数据列；
在id和property中，name指定属性名称，column指定数据列的名称，type指定属性类型，注意这里的类型是NHB中的类型，而不是.NET或数据库中的数据类型。
另外，对象映射文件名称请按”对象名.hbm.xml”的规范来命名, 最后在映射文件的属性中把操作改为"嵌入的资源"（特别注意这点很重要，我就是没有注意到这。郁闷了很久啊！！！）。
现在重新编译程序并运行测试，就能看到绿条了！
因为Product对象将在后面的案例中多次使用，在这里按与Customer相同的步骤创建它。
// Product单元测试
using
System;
using
NUnit.Framework;
namespace
NHibernateTest
{
///
///
ProductFixture 的摘要说明。
///
[TestFixture]
public
class
ProductFixture
{
public
ProductFixture() { }
[Test]
//
测试Product对象的CRUD操作。
public
void
TestCRUD()
{
Category c
=
null
;
try
{
c
=
new
Category();
c.CategoryName
=
"
test
"
;
c.Create();
Product p
=
new
Product();
p.ProductName
=
"
test
"
;
p.Category
=
c;
p.SupplierId
=
3
;
p.QuantityPerUnit
=
"
1箱10只
"
;
p.UnitPrice
=
10.5M
;
p.Create();
Product p2
=
new
Product( p.ProductId );
p2.UnitPrice
=
15.8M
;
p2.Update();
Product p3
=
new
Product( p.ProductId );
Assert.AreEqual( p3.UnitPrice,
15.8M
,
"
update fail!
"
);
p3.Delete();
}
finally
{
if
( c
!=
null
&&
c.CategoryId
>
0
) c.Delete();
}
}
}
}
using
System;
namespace
NHibernateTest
{
///
///
Product 的摘要说明。
///
public
class
Product : BizObject
{
public
Product() :
base
() { }
public
Product(
int
existingId ) :
base
( existingId ) { }
#region
persistent properties
private
int
_productId
=
0
;
private
string
_productName
=
string
.Empty;
private
int
_supplierId
=
0
;
//
应使用many-to-one, 需要重构。
//
private int _categoryId = 0;
//
应使用many-to-one, 需要重构。
private
Category _category;
private
string
_quantityPerUnit
=
string
.Empty;
private
decimal
_unitPrice
=
0
;
private
int
_unitsInStock
=
0
;
private
int
_unitsOnOrder
=
0
;
private
int
_reorderLevel
=
0
;
private
bool
_discontinued
=
false
;
public
int
ProductId
{
get
{
return
_productId; }
set
{ _productId
=
value; }
}
public
string
ProductName
{
get
{
return
_productName; }
set
{ _productName
=
value; }
}
public
int
SupplierId
{
get
{
return
_supplierId; }
set
{ _supplierId
=
value; }
}
//
public int CategoryId
//
{
//
get { return _categoryId; }
//
set { _categoryId = value; }
//
}
public
Category Category
{
get
{
return
_category; }
set
{ _category
=
value; }
}
public
string
QuantityPerUnit
{
get
{
return
_quantityPerUnit; }
set
{ _quantityPerUnit
=
value; }
}
public
decimal
UnitPrice
{
get
{
return
_unitPrice; }
set
{ _unitPrice
=
value; }
}
public
int
UnitsInStock
{
get
{
return
_unitsInStock; }
set
{ _unitsInStock
=
value; }
}
public
int
UnitsOnOrder
{
get
{
return
_unitsOnOrder; }
set
{ _unitsOnOrder
=
value; }
}
public
int
ReorderLevel
{
get
{
return
_reorderLevel; }
set
{ _reorderLevel
=
value; }
}
public
bool
Discontinued
{
get
{
return
_discontinued; }
set
{ _discontinued
=
value; }
}
#endregion
}
}
// Product对象(注意，注释部分并不是无意义的，是在不同的情况下做测试用的，本文中的注释都基本如此）
// 映射文件
xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0">
<class name="NHibernateTest.Product, NHibernateTest" table="Products">
<id name="ProductId" column="productId" type="Int32" unsaved-value="0">
<generator class="identity"/>
id>
<property name="ProductName" column="ProductName" type="String" />
<property name="QuantityPerUnit" column="QuantityPerUnit" type="String" />
<property name="UnitPrice" column="unitPrice" type="Decimal" />
<property name="UnitsInStock" column="unitsInStock" type="Int32" />
<property name="UnitsOnOrder" column="unitsOnOrder" type="Int32" />
<property name="ReorderLevel" column="reorderLevel" type="Int32" />
<property name="Discontinued" column="discontinued" type="Boolean" />
<property name="SupplierId" column="SupplierId" type="Int32" />
<many-to-one name="Category" column="categoryId" unique="true" class="NHibernateTest.Category, NHibernateTest" />
class>
hibernate-mapping>
注意：因为在数据库中，products表与categories表、suppliers表有外键约束，必须先删除这两个约束，product测试用例才能通过，后面我们再加上这两个约束。
现在我们已经掌握了NHB的基本CRUD操作了，整个过程应该说是比较简单吧。呵呵，不再需要使用Connection、DataAdapter、DataSet/DataReader之类的对象了，下面继续学习NHB中更为复杂的映射关系。
3. one-to-one
一对一是一种常见的数据模型，它有两种情况：一种是主键(PrimaryKey)关联；另一种是外健(ForeignKey)关联，在使用外健的时候要保证其唯一性。
在主键关联的情况下, 必须有一个主键是根据别一个主键而来的。NHB是通过一种特殊的方式来处理这种情况的, 要注意两个主健名称必须同名，而外健关联需要在one-to-one配置中定义一个property-ref属性, 这个属性在当前版本的NHB（这是指的是nhibernate 0.5.3,当前的版本是什么情况我现在也没有时间了解）中还没有实现。
在罗斯文商贸应用，不需要使用one-to-one映射，这里先不对其进行讲解，如欲了解one-to-one方面的应用，请参考我网站上的文章。
4. many-to-one
many-to-one是描述多对一的一种数据模型，它指定many一方是不能独立存在的，我个人认为many-to-one是NHB中保证数据有效性的最有用的一种映射，通过使用many-to-one能有效的防治孤儿记录被写入到数据表中。
在罗斯文商贸数据中，Product(产品)与Category(类别)是多对一的关系。下面我们来处理这一映射关系,
首先要让Category能实现基本的CRUD操作，步骤同上, 这里只列出测试用例，类和映射文件请参照上面的方式创建。
[TestFixture]
public
class
CategoryFixture
{
public
CategoryFixture()
{
}
[Test]
//
测试基本的CRUD操作。
public
void
TestCRUD()
{
Category c
=
new
Category();
c.CategoryName
=
"
category1
"
;
c.Description
=
"
category1
"
;
c.Create();
Category c2
=
new
Category(c.CategoryId);
c2.CategoryName
=
"
testupdated
"
;
c2.Update();
Category c3
=
new
Category( c.CategoryId);
Assert.AreEqual( c3.CategoryName,
"
testupdated
"
,
"
update fail!
"
);
c3.Delete();
}
}
上面的测试用例通过后，接着修改Product的各部分。
Product测试用例修改如下:
Product类做如下修改:
1. 删除categoryId 字段和CategoryId属性;
2. 加入以下代码:
public Category Category {
get { return _category; }
set { _category = value; }
}
private Category _category;
Product映射文件做如下修改:
class="NHibernateTest.Business.Category, NHibernateTest" />
这里用到了一个many-to-one标签，用于指定与one的一方进行关联的对象信息。
name指定one一方在对象中的名称;
column指定映射数据列的名称;
unique指定one一方是唯一的;
class 指定one一方类的全名，包括程序集名称;
重新编译程序，运行测试用例, 看到绿条了吗？没有就根据异常去除错吧！我已经看到绿条了。：）
声明: 因为过多的many-to-one使后面的测试代码变得异常庞大（创建对象时要创建one一方的类），所以在后面的代码中，我假定Product对象是没有实现任何many-to-one映射的。如果不怕麻烦，请自行修改后面测试用例。
5. one-to-many
一对多也是一种常见的数据模型，在按范式设计的数据库中随处可见。在NHB中通过one-to-many可以非常方便的处理这种模型，同时NHB还提供了级联更新和删除的功能，以保证数据完整性。
在罗斯文商贸案例中，Customer与Order(订单)、Order和OrderItem(订单项目)就是一对多的关系，值得注意的是，并不是所有一对多关系都应该在NHB中实现，这取决于实际的需求情况，无谓的使用one-to-many映射只会降低NHB的使用性能。
下面先让Order和OrderItem对象能单独的完成CRUD操作，按上面处理Customer的方法来创建测试用例和类，
using
System;
using
NUnit.Framework;
using
System.Collections;
namespace
NHibernateTest
{
///
///
OrderFixture 的摘要说明。
///
[TestFixture]
public
class
OrderFixture
{
public
OrderFixture()
{
}
[Test]
//
测试Order对象的CRUD操作。
public
void
TestCRUD()
{
Order o
=
new
Order();
o.CustomerId
=
"
ALFKI
"
;
o.EmployeeId
=
1
;
o.RequiredDate
=
new
DateTime(
2005
,
9
,
10
);
o.ShippedDate
=
new
DateTime(
2005
,
8
,
28
);
o.ShipVia
=
1
;
o.Freight
=
20.5M
;
o.ShipName
=
"
test name
"
;
o.ShipAddress
=
"
test address
"
;
o.Create();
Order o2
=
new
Order( o.OrderId );
o2.Freight
=
21.5M
;
o2.ShipAddress
=
"
update address
"
;
o2.Update();
Order o3
=
new
Order( o.OrderId );
Assert.AreEqual( o3.Freight,
21.5M
,
"
update order fail!
"
);
Assert.AreEqual( o3.ShipAddress,
"
update address
"
,
"
update order fail!
"
);
o3.Delete();
}
[Test]
//
测试OrderItem对象的CRUD操作。
public
void
TestItemCRUD()
{
Order o
=
null
;
Product p
=
null
;
try
{
o
=
new
Order();
o.RequiredDate
=
new
DateTime(
2005
,
9
,
10
);
o.ShippedDate
=
new
DateTime(
2005
,
8
,
28
);
o.CustomerId
=
"
ALFKI
"
;
o.EmployeeId
=
1
;
o.ShipVia
=
1
;
o.Freight
=
20.5M
;
o.ShipName
=
"
test name
"
;
o.ShipAddress
=
"
test address
"
;
o.Create();
p
=
new
Product();
p.ProductName
=
"
test
"
;
p.UnitPrice
=
11.1M
;
p.SupplierId
=
3
;
p.Create();
OrderItem item
=
new
OrderItem();
//
item.OrderId = 10248;
item.Order
=
o;
//
item.ProductId = 1;
item.Product
=
p;
item.UnitPrice
=
10.5M
;
item.Quantity
=
12
;
item.Discount
=
1
;
item.Create();
OrderItem item2
=
new
OrderItem( item.ItemId );
item2.Quantity
=
13
;
item2.Update();
OrderItem item3
=
new
OrderItem( item.ItemId );
Assert.AreEqual( item3.Quantity,
13
,
"
update orderitem fail!
"
);
item3.Delete();
}
finally
{
if
( o
!=
null
&&
o.OrderId
>
0
) o.Delete();
if
( p
!=
null
&&
p.ProductId
>
0
) p.Delete();
}
}
[Test]
public
void
TestOrderItem()
{
Product p
=
null
;
Product p2
=
null
;
try
{
p
=
new
Product();
p.ProductName
=
"
test
"
;
p.UnitPrice
=
11.1M
;
p.SupplierId
=
3
;
p.Create();
p2
=
new
Product();
p2.ProductName
=
"
test2
"
;
p2.UnitPrice
=
18.1M
;
p2.SupplierId
=
3
;
p2.Create();
Order o
=
new
Order();
o.CustomerId
=
"
ALFKI
"
;
o.EmployeeId
=
1
;
o.RequiredDate
=
new
DateTime(
2005
,
9
,
10
);
o.ShippedDate
=
new
DateTime(
2005
,
8
,
28
);
o.ShipVia
=
1
;
o.Freight
=
20.5M
;
o.ShipName
=
"
test name
"
;
o.ShipAddress
=
"
test address
"
;
o.Create();
OrderItem item
=
new
OrderItem();
item.Product
=
p;
item.UnitPrice
=
10
;
item.Quantity
=
5
OrderItem item2
=
new
OrderItem();
item2.Product
=
p2;
item2.UnitPrice
=
11
;
item2.Quantity
=
4
;
o.AddItem(item);
o.AddItem(item2);
o.Create();
Order o2
=
new
Order( o.OrderId );
Assert.IsNotNull( o2.Items,
"
add item fail!
"
);
Assert.AreEqual( o2.Items.Count,
2
,
"
add item fail!
"
);
IEnumerator e
=
o2.Items.GetEnumerator();
e.MoveNext();
OrderItem item3
=
e.Current
as
OrderItem;
o2.RemoveItem( item3 );
o2.Update();
item3.Delete();
Order o3
=
new
Order( o.OrderId );
Assert.AreEqual( o3.Items.Count,
2
,
"
remove item fail!
"
);
o3.Delete();
}
finally
{
if
(p
!=
null
&&
p.ProductId
>
0
) p.Delete();
if
(p2
!=
null
&&
p2.ProductId
>
0
) p2.Delete();
}
}
}
}
[Test] // 测试OrderItem对象的CRUD操作。
public void TestItemCRUD() {
OrderItem item = new OrderItem();
item.OrderId = 1;
item.ProductId = 1;
item.UnitPrice = 10.5M;
item.Quantity = 12;
item.Discount = 1;
item.Create();
OrderItem item2 = new OrderItem( item.ItemId );
item2.Quantity = 13;
item2.Update();
OrderItem item3 = new OrderItem( item.ItemId );
Assert.AreEqual( item3.Quantity, 13, "update orderitem fail! " );
item3.Delete();
}
}
// Order
这个太长了，不贴了，自己看代码吧。
// Order映射文件
xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0">
<class name="NHibernateTest.Order, NHibernateTest" table="Orders">
<id name="OrderId" column="orderId" type="Int32" unsaved-value="0">
<generator class="identity"/>
id>
<property name="OrderDate" column="orderDate" type="DateTime" />
<property name="RequiredDate" column="requiredDate" type="DateTime" />
<property name="ShippedDate" column="shippedDate" type="DateTime" />
<property name="Freight" column="freight" type="Decimal" />
<property name="ShipName" column="shipName" type="String" />
<property name="ShipAddress" column="shipAddress" type="String" />
<property name="ShipCity" column="shipCity" type="String" />
<property name="ShipRegion" column="shipRegion" type="String" />
<property name="ShipPostalCode" column="shipPostalCode" type="String" />
<property name="ShipCountry" column="shipCountry" type="String" />
<property name="CustomerId" column="customerId" type="String" />
<property name="EmployeeId" column="employeeId" type="Int32" />
<property name="ShipVia" column="shipVia" type="Int32" />
<bag name="_Items" cascade="all" inverse="true">
<key column="orderId"/>
<one-to-many class="NHibernateTest.OrderItem, NHibernateTest" />
bag> class> hibernate-mapping>
// OrderItem
using
System;
namespace
NHibernateTest
{
///
///
OrderItem 的摘要说明。
///
public
class
OrderItem : BizObject
{
public
OrderItem() :
base
() { }
public
OrderItem(
int
existingId ) :
base
( existingId ) { }
#region
persistent properties
private
int
_itemId
=
0
;
//
private int _orderId = 0;
//
many-to-one, 需要重构.
private
Order _order;
//
private int _productId = 0;
//
many-to-one, 需要重构.
private
Product _product;
private
decimal
_unitPrice
=
0
;
private
int
_quantity
=
0
;
private
double
_discount
=
0.0
;
public
int
ItemId
{
get
{
return
_itemId; }
set
{ _itemId
=
value; }
}
//
public int OrderId
//
{
//
get { return _orderId; }
//
set { _orderId = value; }
//
}
//
public int ProductId
//
{
//
get { return _productId; }
//
set { _productId = value; }
//
}
public
Order Order
{
get
{
return
_order; }
set
{ _order
=
value; }
}
public
Product Product
{
get
{
return
_product; }
set
{ _product
=
value; }
}
public
decimal
UnitPrice
{
get
{
return
_unitPrice; }
set
{ _unitPrice
=
value; }
}
public
int
Quantity
{
get
{
return
_quantity; }
set
{ _quantity
=
value; }
}
public
double
Discount
{
get
{
return
_discount; }
set
{ _discount
=
value; }
}
#endregion
}
}
// OrderItem映射文件
因为设计上的原因(业务对象必须为单主健)，我们向OrderDetails加入一个ItemId字段，这是一个自增型的主健，以代替原来的联合主健。
编译并运行测试，检查错误直到单元测试全部通过。
注意，在数据库中要进行如下修改，测试用例才能通过
1．orders表与customers表、employeess表和shippers表有外键约束，必须暂时将它们删除，后面我们再加上这三个约束；
2．将Order Details改名为OrderDetails，表名中出现空格将导致NHB无法解析；
3．orderDetails表与orders表、products表有外健约束，必须暂时将它们删除，下面我们将加上这些约束。
现在开始重构OrderItem的测试用例和对象，主要是加入many-to-one映射。
先将TestItemCRUD修改为如下：
[Test] // 测试OrderItem对象的CRUD操作。
public void TestItemCRUD() {
Order o = null;
Product p = null;
try {
Order o = new Order();
o.CustomerId = "AA001";
o.EmployeeId = 1;
o.Create();
Product p = new Product();
p.ProductName = "test";
p.UnitPrice = 11.1M;
p.Create();
OrderItem item = new OrderItem();
// item.OrderId = 1;
item.Order = o;
// item.ProductId = 1;
item.Product = p;
item.UnitPrice = 10.5M;
item.Quantity = 12;
item.Discount = 1;
item.Create();
OrderItem item2 = new OrderItem( item.ItemId );
item2.Quantity = 13;
item2.Update();
OrderItem item3 = new OrderItem( item.ItemId );
Assert.AreEqual( item3.Quantity, 13, "update orderitem fail! " );
item3.Delete();
}
finally {
if ( o != null && o.OrderId > 0 ) o.Delete();
if ( p != null && p.ProductId > 0 ) p.Delete();
}
}
接下来修改OrderItem对象，改动如下：
// private int _orderId = 0; // many-to-one, 需要重构.
private Order Order;
// private int _productId = 0; // many-to-one, 需要重构.
private Product Product;
删除OrderId和ProductId属性，并加入以下属性:
public Order Order {
get { return _order; }
set { _order = value; }
}
public Product Product {
get { return _product; }
set { _product = value; }
}
编译项目，确保其能通过，如出现错误，请检查是否有拼写错误。
最后修改OrderItem对象的映射文件，改动如下:
class=”NHibernateTest.Business.Order, NHibernateTest” />
class=”NHibernateTest.Business.Product, NHibernateTest” />
按many-to-one一节中的说明对Order和Product对象设置many-to-one关联。
重新生成项目，以使改动的资源编译进程序集中，运行TestItemCRUD测试用例，这时应能得到一个绿条，如果是红条，请根据错误信息进行检查。
接下来重构Order测试用例和对象。
先添加一个TestOrderItem用例如下:
[Test]
public void TestOrderItem() {
Product p = null;
Product p2 = null;
try {
p = new Product();
p.ProductName = "test";
p.UnitPrice = 11.1M;
p.Create();
p2 = new Product();
p2.ProductName = "test2";
p2.UnitPrice = 12.2M;
p2.Create();
Order o = new Order();
o.CustomerId = "AA001";
o.EmployeeId = 1;
o.Create();
OrderItem item = new OrderItem();
item.Product = p;
item.UnitPrice = 10;
item.Quantity = 5;
OrderItem item2 = new OrderItem();
item2.Product = p2;
item2.UnitPrice = 11;
item2.Quantity = 4;
o.AddItem( item );
o.AddItem( item2 );
o.Create();
Order o2 = new Order( o.OrderId );
Assert.IsNotNull( o2.Items, "add item fail! " );
Assert.AreEqual( o2.Items.Count, 2, "add item fail! " );
IEnumerator e = o2.Items.GetEnumerator();
e.MoveNext();
OrderItem item3 = e.Current as OrderItem;
o2.RemoveItem( item3 );
o2.Update();
Order o3 = new Order( o.OrderId );
Assert.AreEqual( o3.Items.Count, 1, "remove item fail! " );
o3.Delete();
}
finally {
if (p!=null && p.ProductId > 0) p.Delete();
if (p2!=null && p2.ProductId >0) p2.Delete();
}
}
在这个测试用例中，我们在Order对象中封装了对OrderItem的添加和移除操作，提供一个ICollection类型的属性Items用于遍历OrderItem。
接着修改Order对象，要添加两个方法和一个属性、一些辅助字段.
public void AddItem( OrderItem item ) {
if ( _items == null ) _items = new ArrayList();
item.Order = this;
_items.Add( item );
}
public void RemoveItem( OrderItem item ) {
_items.Remove( item );
}
public ICollection Items {
return _items;
}
protected IList _Items {
get { return _items; }
set { _items = value; }
}
private IList _items;
在上面加入的代码中，有个protected修饰的_Items属性，它是用于one-to-many映射的，由NHB使用。
最后修改Order对象的映射文件，加入以下one-to-many代码:
这里又用到了一个新的标签bag, bag用于集合映射，在NHB中还有set, list等，它们的元素大致相同，但对应的.NET集合对象却是不一样的，后面对它们进行详细的说明和比较。
bag属性用于指定集合的名称和级联操作的类型;
key元素指定关联的数据列名称;
one-to-many指定many一方类的全名，包括程序集名称。
再次编译项目并运行测试用例，我得到了一个这样的诊断错误信息：
NHibernateTest.OrderFixture.TestOrderItem : NHibernate.ADOException : could not synchronize database state with session
----> System.Data.SqlClient.SqlException : DELETE 语句与 COLUMN REFERENCE 约束 'FK_Order_Details_Products' 冲突。该冲突发生于数据库 'Northwind'，表 'Order Details', column 'ProductID'。
语句已终止。
从源代码可以得知，当执行Update操作时，级联操作并不会删除我们移除的子对象，必须自行删除！级联删除只是指删除父对象的时候同时删除子对象。
修改TestOrderItem测试用例代码如下：
o2.Update(); // 此行不变
item3.Delete(); // 加入此行代码
6. element(这个我没有做，自己加入调试吧！）
集合element是一种处理多对多的映射，多对多在数据库中也是常见的数据模型，像用户与组，用户与权限等。多对多关系需要通过一个中间表实现，element的就是读取这个中间表中某列的值。
在罗斯文商贸应用中，Employee和Territory之间是多对多的关系，它们通过EmployeeTerritories表进行关联。 有关Employee和Territory对象的代码、测试用例和映射文件请自行参照上面的方法创建，这里就不列出代码了，下面只列出测试element映射的部分。
[TestFixture]
public class EmployeeFixture() {
// other test....
[test]
public TerritoryElementTest() {
Employee e = new Employee();
e.FirstName = “first”;
e.LastName = “last”;
e.AddTerritory( 1000 );
e.AddTerritory( 1001 );
e.Create();
Employee e2 = new Employee( e.EmployeeId );
Assert.IsNotNull( e2.Territories, “add territory fail!” );
Assert.AreEqual( e2.Territories.Count, 2, “add territory fail!” );
e2.RemoveTerritory( 1000 );
e2.Update();
Employee e3 = new Employee( e.EmployeeId );
Assert.AreEqual( e3.Territories.Count, 1, “remove territory fail!” );
e3.Delete();
}
}
在上面的代码中，我们给Employee添加两个方法和一个属性，这和one-to-many一节中介绍的处理方法是相似的。
在Employee类中，要添加如下代码:
public class Employee {
// other fields , properties, method...
public void AddTerritory( int territoryId ) {
if ( _territory == null ) _territory = new ArrayList();
_territory.Add( territoryId );
}
public void RemoveTerritory( int territoryId ) {
_territory.Remove( teritoryId );
}
public ICollection Territories {
get { return _territory; }
}
protected IList _Territories {
get { return _territories; }
set { _territories = value; }
}
}
最后修改Employee对象的映射文件，加入以下内容:
在bag标签中，加入了一个table属性，它指定一个实现多对多的中间表。在element元素中，指定要读取的列名及其类型。
四 数据加载
1. Expression
Expression数据加载由ICriteria接口实现, ICriteria在程序中是无法直接构造的，必须通过ISession.CreateCriteria(type)来获得。ICriteria主要负责存储一组Expression对象和一组Order对象，当调用List执行查询时，ICriteria对Expression对象和Order对象进行组合以产生NHB内部的查询语句，然后交由DataLoader(数据加载器)来读取满足条件的记录。
下面列出ICriteria接口中的一些常用方法：
Add：加入条件表达式(Expression对象)，此方法可多次调用以组合多个条件；
AddOrder：加入排序的字段(Order对象)；
List：执行查询, 返回满足条件的对象集合。
SetMaxResults：设置返回的最大结果数，可用于分页；
SetFirstResult：设置首个对象返回的位置，可用于分页；
通过SetMaxResults和SetFirstResult方法，就可以取得指定范围段的记录，相当于是分页，
！！！ 要说明的是，对于SQL Server数据库，它是使用将DataReader指针移到firstResult位置，再读取maxResults记录的方式来实现分页的，在数据量非常大（10w以上）的情况下，性能很难保证。
所有表达式对象都继承之Expression类，这是一个抽象(abstract)类, 同时也是一个类工厂(Factory Method模式), 用于创建派生的Expression对象，这样就隐藏了派生类的细节。(又学到一招了吧！)
下面列出几个常用的Expression对象:
EqExpression ：相等判断的表达式, 等同于 propertyName = value，由Expression.Eq取得;
GtExpression ：大于判断的表达式, 等同于 propertyName > value，由Expression.Gt取得;
LikeExpression ：相似判断的表达式, 等同于 propertyName like value，由Expression.Like取得；
AndExpression ：对两个表达式进行And操作, 等同于 expr1 and expr2，由Expression.And取得;
OrExpression ：对两个表达式进行Or操作, 等同于 expr1 or expr2，由Expression.Or取得;
更多的Expression对象请参考相关文档或源代码。
Order对象用于向ICriteria接口提供排序信息，这个类提供了两个静态方法，分别是Asc和Desc，顾名思义就是创建升序和降序的Order对象，例如要取得一个按更新日期(Updated)降序的Order对象, 使用Order.Desc("Updated")就可以了。
下面以加载Customer数据为例来说明Expression的使用:
测试代码如：
using
System;
using
NHibernate.Hql;
using
NHibernate.Expression;
using
NHibernate.Type;
using
NUnit.Framework;
using
System.Collections;
namespace
NHibernateTest
{
///
///
CustomerSystemFixture 的摘要说明。
///
[TestFixture]
public
class
CustomerSystemFixture
{
public
CustomerSystemFixture()
{
}
[Test]
public
void
LoadByNameTest()
{
ICriterion crit
=
Expression.Eq(
"
CompanyName
"
,
"
company name
"
);
IList custs
=
ObjectLoader.Find(crit,
typeof
(Customer));
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadByNamePagerTest()
{
ICriterion crit
=
Expression.Eq(
"
CompanyName
"
,
"
company name
"
);
PagerInfo pi
=
new
PagerInfo(
0
,
5
);
IList custs
=
ObjectLoader.Find(crit,
typeof
(Customer) , pi);
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadByNameAndAddressTest()
{
ICriterion crit
=
Expression.Eq(
"
CompanyName
"
,
"
company name
"
);
ICriterion crit2
=
Expression.Eq(
"
Address
"
,
"
address
"
);
IList custs
=
ObjectLoader.Find(Expression.And(crit, crit2),
typeof
(Customer));
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadByNameOrAddressTest()
{
ICriterion crit
=
Expression.Eq(
"
CompanyName
"
,
"
company name
"
);
ICriterion crit2
=
Expression.Eq(
"
Address
"
,
"
address
"
);
IList custs
=
ObjectLoader.Find(Expression.Or(crit, crit2),
typeof
(Customer));
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadAllTest ()
{
string
query
=
"
from Customer
"
;
IList custs
=
ObjectLoader.Find( query,
null
);
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadPagerDataTest()
{
string
query
=
"
from Customer
"
;
PagerInfo pi
=
new
PagerInfo(
0
,
5
);
IList custs
=
ObjectLoader.Find( query,
null
, pi );
}
[Test]
public
void
LoadByName2Test()
{
IList paramInfos
=
new
ArrayList();
string
query
=
"
from Customer c where c.CompanyName = :CompanyName
"
;
paramInfos.Add(
new
ParamInfo(
"
CompanyName
"
,
"
test name
"
,TypeFactory.GetStringType()) );
IList custs
=
ObjectLoader.Find( query, paramInfos );
//
根据期望的结果集写Assertion.
}
[Test]
public
void
LoadByNameAndAddress2Test()
{
IList paramInfos
=
new
ArrayList();
string
query
=
"
from Customer c where c.CompanyName = :CompanyName and c.Address = :Address
"
;
paramInfos.Add(
new
ParamInfo(
"
CompanyName
"
,
"
test name
"
,TypeFactory.GetStringType()));
paramInfos.Add(
new
ParamInfo(
"
Address
"
,
"
test address
"
,TypeFactory.GetStringType()));
IList custs
=
ObjectLoader.Find( query, paramInfos );
//
根据期望的结果集写Assertion.
}
}
}
在上面的代码中，给出了四个较简单的表达式加载的测试用例，它们都通过调用ObjectLoader对象的Find方法来取得数据，ObjectLoader是我们自己的数据加载器，它简单的封装了NHB中的数据加载功能。另外，我们还用一个PagerInfo类封装了分页数据，以方便数据传递。
注意：以前代码是这么写的
[Test]
public void LoadByNameTest() {
Expression expr = Expression.Eq( “CompanyName”, “company name” );
IList custs = ObjectLoader.Find( expr, typeof(Customer) );
// 根据期望的结果集写Assertion.
}
对比下现在的写法：
[Test]
public void LoadByNameTest()
{
ICriterion crit = Expression.Eq("CompanyName", "company name");
IList custs = ObjectLoader.Find(crit, typeof(Customer));
// 根据期望的结果集写Assertion.
}
这个应该是NHibernate的版本引起的变化。
2. HQL
HQL（Hibernate Query Language）是NHB的专用查询语言，它完全面向对象！就是说只需要知道对象名和属性名就可以生成HQL了，这样就再也不用去理会数据表和列了，前面说的Expression查询最终也会转换为HQL。
有两种方式来执行HQL，一种是直接使用ISession的Find方法，另一种是使用IQuery接口。IQuery接口提供了一些额外的设置，最重要的就是分页了，这个和ICriteria差不多，另外一些就是设置参数的值了。
NHB中有一组类专门用于完成数据加载，它们分别对应不同的数据加载情况，如实体加载、Criteria加载、OneToMany加载等。
下面同样以加载Customer数据为例来说明HQL的使用:
在上面的CustomerSystemFixture类中加入以下几个测试用例:
public class CustomerSystemFixture {
[Test]
public void LoadAllTest () {
string query = “ from Customer “;
IList custs = ObjectLoader.Find( query, null );
// 根据期望的结果集写Assertion.
}
[Test]
public void LoadPagerDataTest() {
string query = “ from Customer “;
PagerInfo pi = new PagerInfo( 0, 5 );
IList custs = ObjectLoader.Find( query, null, pi );
}
[Test]
public void LoadByName2Test() {
string query = “ from Customer c where c.CompanyName = :CompanyName “;
paramInfos.Add( new ParameterInfo(“CompanyName”, “test name”, TypeFactory.GetStringType()) );
IList custs = ObjectLoader.Find( query, paramInfos );
// 根据期望的结果集写Assertion.
}
[Test]
public void LoadByNameAndAddress2Test() {
string query = “ from Customer c where c.CompanyName = :CompanyName and c.Address = :Address“;
paramInfos.Add( new ParameterInfo(“CompanyName”, “test name”, TypeFactory.GetStringType()) );
paramInfos.Add( new ParameterInfo(“Address”, “test address”, TypeFactory.GetStringType()) );
IList custs = ObjectLoader.Find( query, paramInfos );
// 根据期望的结果集写Assertion.
}
}
在上面的测试用例中，我们同样将数据加载交由ObjectLoader的Find方法来处理，Find有很多重载的版本，都用于数据加载。另外还使用了一个ParameterInfo类来存储HQL语句的参数信息。
// ParamInfo
public class ParamInfo {
private string name; // 参数名称
private object value; // 参数值
private IType type; // 参数类型
public ParamInfo( string name, object value, IType type ) {
this.name = name;
this.value = value;
this.type = type;
}
public string Name {
get { return name; }
}
public object Value {
get { return value; }
}
public IType Type {
get { return type; }
}
} //class ParamInfo
向ObjectLoader类加入以下方法:
public class ObjectLoader {
// ....
public static IList Find( string query, ICollection paramInfos ) {
return Find( query, paramInfos, null );
}
public static IList Find( string query, ICollection paramInfos, PagerInfo pi ) {
ISession s = Sessions.GetSession();
try {
IQuery q = s.CreateQuery( query );
if ( paramInfos != null ) {
foreach ( ParamInfo info in paramInfos ) {
if ( info.Value is ICollection )
q.SetParameterList( info.Name, (ICollection)info.Value, info.Type );
else
q.SetParameter( info.Name, info.Value, info.Type );
}
}
if ( pi != null ) {
q.SetFirstResult( pi.FirstResult );
q.SetMaxResults( pi.MaxResults );
}
return q.List();
}
finally {
s.Close();
}
}
}
在上面的Find方法中，通过HQL语句创建一个IQuery, 然后加入参数，接着设置分页数据，最后返回列出的数据。
五 事务（没有做，自己加吧）
既然而数据库打交道，那么事务处理就是必需的，事务能保整数据完整性。在NHB中，ITransaction对象只对.NET的事务对象(实现了IDbTransaction接口的对象)进行了简单的封装。
使用NHB的典型事务处理看起来像下面这样(见ISession.cs的注释)
ISession sess = factory.OpenSession();
Transaction tx;
try {
tx = sess.BeginTransaction();
//do some work
//...
tx.Commit();
}
catch (Exception e) {
if (tx != null) tx.Rollback();
throw e;
}
finally {
sess.Close();
}
事务对象由ISession的BeginTransaction取得,同时事务开始，如果执行顺利则提交事务，否则回滚事务。
当实现一个业务规则时，而这一规则要改变多个业务对象状态时，这时就需要使用事务了，事务能保证所有改变要么全部保存，要么全部不保存！
在罗斯文商贸案例中，有这样一个业务规则：
如果客户对某一产品下了订单，那么被订购产品的已订购数量（UnitsOnOrder）应该加上客户的产品订单量，根据这一业务规则，创建一个测试用例如下:
[TestFixture]
public class OrderFixture {
[Test]
public void OrderTest() {
Product p = new Product();
p.UnitsOnOdrer = 20;
p.Create();
Order o = new Order();
OrderItem item = new OrderItem();
item.Order = o;
item.Product = p;
item.OrderNum = 10;
OrderCO.Create( o );
Product p2 = new Product( p.ProductId );
Assert.AreEqual( p2.UnitsOnOrder, 30, “add to unitsonorder fail!” );
}
}
[Test]
//
测试Product对象的CRUD操作。
public
void
TestCRUD()
{
Category c
=
null
;
try
{
c
=
new
Category();
c.CategoryName
=
"
test
"
;
c.Create();
Product p
=
new
Product();
p.ProductName
=
"
test
"
;
p.Category
=
c;
p.SupplierId
=
3
;
p.QuantityPerUnit
=
"
1箱10只
"
;
p.UnitPrice
=
10.5M
;
p.Create();
Product p2
=
new
Product( p.ProductId );
p2.UnitPrice
=
15.8M
;
p2.Update();
Product p3
=
new
Product( p.ProductId );
Assert.AreEqual( p3.UnitPrice,
15.8M
,
"
update fail!
"
);
p3.Delete();
}
finally
{
if
( c
!=
null
&&
c.CategoryId
>
0
) c.Delete();
}
}
评论
回复 引用 查看
请问NHibernate是用于B/S还是C/S中的?
还有就是那些Customer类,product类是自动生成的还是自己写的,可以用其它工具比如codeSmith,SmartForge之类的工具生成吗?
还没用过这些工具,大家不要笑话 :D
回复 引用 查看
不过我现在在寻找一个很好的NHibernate封装类，和上面的一个类很相似，
如果这个封装类做得够好，那么NHibernate的操作就会比DataAccess Block
更来的简单～
回复 引用 查看
还有就是把测试代码写在一起,那发布dll的时候也包括进去了,是这样的吗
回复 引用 查看
我开始接触的时候也有你那样的忧虑，如果这样的实体类也要自己全部负责写
(包括相关的映射文件)，那么工作量会很大，而且维护也不方便，不过还好
网上有很多这样的代码生成工具，可以针对数据库中表自动生成相关的映射
文件，这样就很方便了
做得比较好得有 飞鹰的 coolcoder 等
回复 引用 查看
回复 引用 查看
最近需要把做的项目搬到Oracle数据库，发现个问题。
用参数替换SetParameter得到的IList的Count竟然是0，但是查询条件明显没有错，
而且错误只在参数替换中参数类型是String的情况下。
但是我用Hql作为查询就能找出数据来，不知道为何。
Nhibernate版本已经最近0.9.1.0
配置是方言是Oracle9Dialect。
驱动OracleDataClientDriver。
使用ODP连接。
回复 引用 查看
O/R Mapping适合于大型B/S结构的开发吗?
我始终觉得这种架构适合于一些Windows应用程序或工具软件的开发. 并不适合于制作大访问量的B/S架构, 不然一些开源的大型B/S项目为什么不用O/R模式呢?
回复 引用 查看
回复 引用 查看
回复 引用 查看
业务数据就是业务数据，不要掺杂操作在里面。也不利于事务处理。
回复 引用 查看
BTW：这篇文章我看得比较明白，同时感谢一下原作者！
回复 引用 查看
怎么上面有些老兄刚好把这个过程反过来了，那不是变成了ROM？
还请高手指教！
回复 引用 查看
回复 引用 查看
回复 引用 查看
回复 引用 查看
呵..学习中..
回复 引用 查看
回复 引用 查看
NHibernateTest.SessionsFixture.FactoryTest : System.IO.FileNotFoundException : File or assembly name Iesi.Collections, or one of its dependencies, was not found.
NHibernateTest.SessionsFixture.GetSessionTest : System.IO.FileNotFoundException : File or assembly name Iesi.Collections, or one of its dependencies, was not found.
回复 引用 查看
能解释一下这句话，怎么在属性修改"嵌入的资源"
最好能把代码贴出来．．．
十分谢谢
回复 引用 查看
回复 引用 查看
public Category Category
{
get { return _category; }
set { _category = value; }
}
Category 这个类和它的映射文件没有吗?
能否把代码贴出来．．．
十分谢谢..
回复 引用 查看
没有了，这只是一篇引导性的文章，如果你真的想详尽的学习NHibernate，我还是建议你直接看NHibernate自带的文档，结合该文档与它自带的例子，你就可以全面而深入的学习NHibernate
回复 引用 查看
多谢了
回复 引用 查看
--------------------------------------------------
错误是:
NHibernate.MappingException : The dialect was not set. Set the property hibernate.dialect.
----> NHibernate.HibernateException : The dialect was not set. Set the property hibernate.dialect.
--------------------------------------------
type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089"
/>
回复 引用 查看
首先我不是女生，其次，我的代码也好像不好找了，如果要学习NHibernate请看NHibernate提供的官方文档吧！对不起了。
回复 引用 查看
这是一个典型的double lock方式，用来产生线程安全的Singletion（单例）对象。
Singletion -> Singleton
回复 引用 查看
下载的压缩包 不能打开
回复 引用 查看
未处理的“NHibernate.InvalidProxyTypeException”类型的异常出现在 nhibernate.dll 中。
其他信息: method get_Id should be virtual
是那里没配置好？？我的版本是1.2.0
回复 引用 查看
回复 引用 查看
谢谢了
[email protected]
回复 引用 查看
现在应该很少有人能够做到先Object,然后再Database的吧~，这应该和Hibernate的初衷相悖啊
回复 引用 查看
@loooog
我看了你的配置文件，应该没有问题，你需要一个MySQL.Data.dll。这个是可以在Mysql的网站上获得 http://www.mysql.com
回复 引用 查看
回复 引用 查看
回复 引用 查看
如果我使用微软的强类型数据集，外加自定义数据源对象
似乎根本就不需要什么NHibernate了
？
回复 引用 查看
回复 引用 查看
回复 引用 查看
回复 引用 查看
回复 引用 查看