Biegral Blog

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
    }
}

[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();
        }
    }

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();
            }

        }

    }
}

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!” );
   }
}