Visual Studio 2005学习的 开源项目 之NHibernate

  现在都在开源  ，可是.net的项目好像 比较少 ，我到目前为止只知道 NHibernate, Spring.net   ,上个礼拜学习了一下 NHibernate ，发现了一个网站 www.vs2005.com  里面有很多VS2005+SQL2005的资料

觉得不错  ，推荐致力于NET学习的网友访问  。 

下面帖下来转载的一篇文章 ，是NHibernate的序篇  ，呵呵 ，其实也没有必要 。但是放到这里装饰我的空间吧   。

开始起步 ~~~

1  NHibernate 与ms  sql Server的操作

 基本的软件环境如下：

1．NHibernate www.nhibernate.org 当前版本是1.0.2
2．Code Smith http://www.codesmithtools.com/
3．NHibernate模板 点击这里下载
当然，少不了VS2005跟SQLServer了，我这里用的是SQLServer2005，教程用在SQLServer2000上应该没有问题，默认情况下，我将建立并使用一个叫NHibernate的数据库。

首先，我们先建立一个最简单的Person表，如下完整脚本（你可以进行修改以适合自己的数据库）：

USE [NHibernate]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[Person](
    [id] [ int ] IDENTITY( 1 , 1 ) NOT NULL,
    [name] [varchar]( 50 ) COLLATE Chinese_PRC_CI_AS NOT NULL,
 CONSTRAINT [PK_Person] PRIMARY KEY CLUSTERED 
(
    [id] ASC
)WITH (IGNORE_DUP_KEY  =  OFF) ON [PRIMARY]
) ON [PRIMARY]

GO
SET ANSI_PADDING OFF

仅有两个字段，一个自动增长的id，一个name，如下：

 
然后将下载的nhibernate-template解压，打开Code Smith，将模板加入”Template Explorer”，如下：

 
然后在其中的NHibernate.cst上点右键，选择“Execute”,弹出设置窗口，在左边的属性窗口进行如下设置：

 
注意：SourceDatabase属性在第一次选择时需要配置一个连接字符串，配置好后Code Smith将记录下来。 Assembly属性代表的是生成文件的默认Assembly名，而NameSpace，顾名思义，就是使用的命名空间了，这里我们全部使用”Test.Model”，请记住这个名字，点击左下角的Generate，将会在指定的输出目录下产生两个文件：Person.cs,Person.hbm.xml。

好了，NHibernate需要的类文件和映射文件生成完了，我们可以开始干活了！（生成NHibernate文件均是如此步骤，以后不再赘述）

新建立一个类库工程，为了简洁起见，我们命名为Model，需要注意的是，为了跟刚才生成的文件对应，我们需要在Model工程的属性页中将起Assembly名字设为上面的“Test.Model”,如下：

 
然后将刚才生成的两个文件Person.cs和Person.hbm.xml加入到Model工程中来，选中Person.hbm.xml文件，在属性窗口中将其“Build Action”设置为“Embedded Resource”(这是非常重要的一步，否则NHibernate将无法找到映射文件)，如下：
 

build，ok，通过。

然后建立一个控制台工程，命名为Console1，添加NHibernate和上面Model项目的引用，另外添加一个应用程序配置文件，如下：

<? 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"   />
   </ configSections >

   < nhibernate >
     < add  key ="hibernate.connection.provider"  value ="NHibernate.Connection.DriverConnectionProvider"   />
     < add  key ="hibernate.connection.driver_class"  value ="NHibernate.Driver.SqlClientDriver"   />
     < add  key ="hibernate.connection.connection_string"  value ="Server=localhost;Initial Catalog=NHibernate;Integrated Security=SSPI"   />
     < add  key ="hibernate.connection.isolation"  value ="ReadCommitted" />
     < add  key ="hibernate.dialect"  value ="NHibernate.Dialect.MsSql2000Dialect"   />
   </ nhibernate >

</ configuration >

然后编写如下代码：

using  System;
using  System.Collections.Generic;
using  System.Text;
using  NHibernate;
using  NHibernate.Cfg;
using  Test.Model;

namespace  Console1
{
    class Program
    {
        static void Main(string[] args)
        {
            Configuration config = new Configuration().AddAssembly("Test.Model");
            ISessionFactory factory = config.BuildSessionFactory();
            ISession session = factory.OpenSession();

            Person person = new Person();
            person.Name = "Jackie Chan";

            ITransaction trans = session.BeginTransaction();
            try
            {
                session.Save(person);
                trans.Commit();
                Console.WriteLine("Insert Success!");
            }
            catch (Exception ex)
            {
                trans.Rollback();
                Console.WriteLine(ex.Message);
            }
        }
    }
}

运行，ok，执行成功！！
我们到数据库检查一下，如下：

 
我们想要添加的记录已经成功加入到数据库中！！
是不是感觉有些神奇啊？好，我们开始详细解释。
先来看生成的两个文件，第一个是Person.cs，如下：

using  System;
using  System.Collections;

namespace  Test.Model
{
    Person#region Person

    /**//// <summary>
    /// Person object for NHibernate mapped table 'Person'.
    /// </summary>
    public class Person
    {
        Member Variables#region Member Variables
        
        protected int _id;
        protected string _name;

        #endregion

        Constructors#region Constructors

        public Person() { }

        public Person( string name )
        {
            this._name = name;
        }

        #endregion

        Public Properties#region Public Properties

        public int Id
        {
            get {return _id;}
            set {_id = value;}
        }

        public string Name
        {
            get { return _name; }
            set
            {
                if ( value != null && value.Length > 50)
                    throw new ArgumentOutOfRangeException("Invalid value for Name", value, value.ToString());
                _name = value;
            }
        }

        

        #endregion
    }
    #endregion
}

你可以发现，这完全是一个普通的poco类（Plain Old CLR Object）,仅仅是对数据库person表的一个完全映射，不依赖于任何框架，可以用来作为持久化类，你可以在任何地方使用而不用担心依赖于某些神秘的运行时东西。

另外，NHibernate需要知道怎样去加载（load）和存储（store）持久化类的对象。这正是NHibernate映射文件发挥作用的地方。映射文件告诉NHibernate它应该访问数据库(database)里面的哪个表（table）及应该使用表里面的哪些字段（column）,这就是我们今天要讲的重点了，Person.hbm.xml，如下：

<? xml version="1.0" encoding="utf-8"  ?>
< hibernate-mapping  xmlns ="urn:nhibernate-mapping-2.0" >
  < class  name ="Test.Model.Person, Test.Model"  table ="Person" >
   < id  name ="Id"  type ="Int32"  unsaved-value ="0" >
    < column  name ="id"  sql-type ="int"  not-null ="true"  unique ="true"  index ="PK_Person" />
    < generator  class ="native"   />
   </ id >
   < property  name ="Name"  type ="String" >
    < column  name ="name"  length ="50"  sql-type ="varchar"  not-null ="true" />
   </ property >
  </ class >
</ hibernate-mapping >

不用说，最顶层的hibernate-mapping节点是NHibernate用来进行映射的根了，其中，包含一个class节点，里面的name属性对应我们的Person类，注意，需要完整的限定名；而table属性，则显而易见是对应数据库中的Person表了。
我们再往里面看，分别有两个节点，一个是id，对应数据库中的id，一个是属性name，对应表中的column name和Person类中的name属性，整个映射文件简捷明了，一看即知。实际上这是由代码产生工具产生的映射文件，里面很多东西我们其实可以省略，如下写法：
<property name=”Name” column=”name” />
NHibernate将自动去匹配数据库中的列而不需要我们来设置。

下面，我们来看一下应用程序配置文件中都记录了那些东西，如下：
hibernate.connection.provider_class  
定制IConnectionProvider的类型.
例如：full.classname.of.ConnectionProvider （如果提供者创建在NHibernate中）, 或者 full.classname.of.ConnectionProvider, assembly （如果使用一个自定义的IConnectionProvider接口的实现，它不属于NHibernate）。
 
hibernate.connection.driver_class  
定制IDriver的类型.
full.classname.of.Driver （如果驱动类创建在NHibernate中）, 或者 full.classname.of.Driver, assembly （如果使用一个自定义IDriver接口的实现，它不属于NHibernate）。

hibernate.connection.connection_string  
用来获得连接的连接字符串.

hibernate.connection.isolation  
设置事务隔离级别. 请检查 System.Data.IsolationLevel 来得到取值的具体意义并且查看数据库文档以确保级别是被支持的。
例如： Chaos, ReadCommitted, ReadUncommitted, RepeatableRead, Serializable, Unspecified

hibernate.dialect 
NHibernate方言（Dialect）的类名 - 可以让NHibernate使用某些特定的数据库平台的特性
例如： full.classname.of.Dialect（如果方言创建在NHibernate中）, 或者full.classname.of.Dialect, assembly （如果使用一个自定义的方言的实现，它不属于NHibernate）。

接着，我们开始解释代码的执行，如下：

 

 

Configuration config  =   new  Configuration().AddAssembly( " Test.Model " );

// 通过配置对象来产生一个SessionFactory对象，这是一个Session工厂，
// 那么Session是用来干什么的呢？一个Session就是由NHibernate封装
// 的工作单元，我们可以近似地认为它起到ADO.Net中Connection的作用。
ISessionFactory factory  =  config.BuildSessionFactory();
ISession session  =  factory.OpenSession();

Person person  =   new  Person();
person.Name  =   " Jackie Chan " ;

// 这里，开启一个由NHibernate封装的事务，当然，在这里最终代表
// 的还是一个真实的数据库事务，但是我们已经不需要再区分到底是
// 一个SqlTransaction还是一个ODBCTransaction了
ITransaction trans  =  session.BeginTransaction();
try
{
    //保存，提交，就这么简单！！
         session.Save(person);
        trans.Commit();
        Console.WriteLine("Insert Success!");
}
catch  (Exception ex)
{
        trans.Rollback();
        Console.WriteLine(ex.Message);
}

2  NHibernate 研究

下面介绍一下 NHibernate 的  背景和发展的趋势 

什么是 NHibernate

NHibernate 是一个基于.Net 的针对关系型数据库的对象持久化类库。Nhibernate 来源于非常优秀的基于Java的Hibernate 关系型持久化工具。

NHibernate 从数据库底层来持久化你的.Net 对象到关系型数据库。NHibernate 为你处理这些，远胜于你不得不写SQL去从数据库存取对象。你的代码仅仅和对象关联，NHibernat 自动产生SQL语句，并确保对象提交到正确的表和字段中去。

 

为什么写这个

 

任何熟悉Hibernate的人会发现这篇文章和Glen Smith 的 A Hitchhiker's Guide to Hibernate 非常相近。这里的内容正是基于他的指南，因此所有的感谢都应该给与他。

NHibernate的文档并非每处都和Hibernate的文档一致。然而，项目的相似应该能使读者通过读Hibernate的文档来很好的理解NHibernate如何工作。

这篇文章意在让你尽可能快的开始使用NHibernate。它将介绍如何持久化一个简单的对象到一张表里。想得到更多的复杂的例子，可以参考NUnit测试及附带代码。

 

开发的过程

 

Nhibernate未来将会提供一些工具帮助你自动产生schema文件（现在还是基于代码）或是通过映射文件产生类（在筹措阶段）或是更新schema(来自于一个新开发者的建议)。然而，这里我们的例子是假定一切来自于完全手写，包括设置表和.Net类的编写。我们将进行以下步骤。

1．新建一个将要持久化.Net对象的表

2．构建一个需要被持久化的.Net类

3．构建一个可以让NHibernate知道如何持久化对象属性的映射文件

4．构建一个让NHibernate知道如何连接数据库的配置文件]

5．使用NHibernate的 API

第一步：写构建表的 SQL

 

这里我们将使用的是一个非常简单的例子。假设你正在为你的网站开发一个基本的用户管理子系统。我们将使用如下的一张User表（假定你已经设置好一个数据库—在的例子里我称它为NHibernate）。

 

use  NHibernate
go
CREATE   TABLE  users (
  LogonID  nvarchar ( 20 )  NOT   NULL   default   ' 0 ' ,
  Name  nvarchar ( 40 )  default   NULL ,
  Password  nvarchar ( 20 )  default   NULL ,
  EmailAddress  nvarchar ( 40 )  default   NULL ,
  LastLogon  datetime   default   NULL ,
   PRIMARY   KEY   (LogonID)
)
go

我使用的是MS Sql Server 2000, 但也可以使用任何数据库，只要你有关于它们的基于.Net数据提供驱动程序。我们将得到一个含有LogonID,Name, Password, Email 和LastLogon的表. 经过以上标准步骤，我们下一步是写一个.Net类处理一个给定的User对象。

 

第二步:产生一个.Net 类文件

 

当内存中有一堆User对象的时候，我们需要某种对象去保存它们。NHibernate通过对象属性的反射来工作，因此我们需要添加我们希望持久化的对象属性。一个可以被NHibernate持久化的类应该看起来象下面的样子：

 

using  System;
namespace  NHibernate.Demo.QuickStart
{
     public   class  User
    {
         private   string  id;
         private   string  userName;
         private   string  password;
         private   string  emailAddress;
         private  DateTime lastLogon;
         public  User()
        {
        }
         public   string  Id
        {
             get  {  return  id; }
             set  { id  =  value; }
        }
         public   string  UserName
        {
             get  {  return  userName; }
             set  { userName  =  value; }
        }
         public   string  Password
        {
             get  {  return  password; }
             set  { password  =  value; }
        }
         public   string  EmailAddress
        {
             get  {  return  emailAddress; }
             set  { emailAddress  =  value; }
        }
         public  DateTime LastLogon
        {
             get  {  return  lastLogon; }
             set  { lastLogon  =  value; }
        }
    }
}

在上面的例子里，我们的属性和构建函数 是public，但这个对NHibernate不是必要的.它可以使用public, protected, internal或者甚至是用private来持久化数据。

第三步：写映射文件

 

现在我们有数据表和需要去映射它的.Net类。我们需要一种方式去让NHibernate知道如何从一个映射到另一个。这个任务依赖于映射文件来完成。最易于管理的办法是为每一个类写一个映射文件，如果你命名它是YourObject.hbm.xml 并且把它放在和类的同一个目录里，NHiberante将会使得事情简单起来。下面是一个User.hbm.xml的例子：

 

<? xml version="1.0" encoding="utf-8"  ?>
< hibernate-mapping  xmlns ="urn:nhibernate-mapping-2.0" >
     < class  name ="NHibernate.Examples.QuickStart.User, NHibernate.Examples"  table ="users" >
         < id  name ="Id"  column ="LogonId"  type ="String"  length ="20" >
             < generator  class ="assigned"   />
         </ id >
         < property  name ="UserName"  column = "Name"  type ="String"  length ="40" />
         < property  name ="Password"  type ="String"  length ="20" />
         < property  name ="EmailAddress"  type ="String"  length ="40" />
         < property  name ="LastLogon"  type ="DateTime" />
     </ class >
</ hibernate-mapping >

让我们来看看这个文件中让我们感兴趣的某些行。第一个有趣的标签是class。这里我们将映射类型名称(类名和装配件)到我们数据库中的User表，这里和Hibernate有一点点的不同。你将不得不告诉NHibernate从何处提取对象。在这个例子里我们从装配件NHibernate.Examples装载类NHibernate.Examples.QuickStart.User 。NHibernate 遵循和.Net Framework同样的规则来加载类型。因此如果你在如何指定类型的方面有些混淆，请参看.Net Framework SDK。

让我们先跳过id标签，来讨论property标签。简要看一下，你将发现NHibernate所要做的工作。name属性的值正是我们.Net 类的属性，column属性值将是我们数据库里的字段。type属性是可选的（如果你不标明，NHibernate将利用反射进行最佳的推测）。

好了，让我们回到标签id, 你可以猜测到这个标签将是映射数据库表的主键，的确如此，id标签的组成和我们刚才看的property标签是相似的。我们映射属性到目标数据库的字段。

内嵌的generator 标签告诉NHibernate 如何生成主键（它将恰当的为你生成主键，不管你指定何种类型，但你必须告诉它）。在我们的例子里，我们设定为assigned,意味着我们对象将自己生成主键（毕竟User对象常常需要一个UserID）。如果你执意要NHiberante为你生成主键，你感兴趣于设定uuid.hex和uuid.string（从文档中获取更多信息）

提示：如果你使用Visual Studio.Net 去编译的话，请将user.hbm.xml的Build Action属性设置为Embedded Resource。映射文件将成为装配件的一部分。更详细的细节重点将在后面展示。

提示：如果你仅仅是改变映射文件，你不能使用build 而应该Rebuild项目。Visual Studio.Net 不会重新编译有改变的映射文件。

第四步：为你的数据库产生一个配置文件

 

我们至今还没有告诉NHibernate 去哪里连接数据库。最直接的办法是在你的应用程序的配置文件里设置一个NHibernate配置节。这和在Hibernate里使用属性文件是等价的。如下配置：

<? xml version="1.0" encoding="utf-8"  ?>
< configuration >
     < configSections >
         < section  name ="nhibernate"  type ="System.Configuration.NameValueSectionHandler, System, Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089"   />
     </ configSections >
     < nhibernate >
         < 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=localhost;initialecatalog=nhibernate;Integrated Security=SSPI"
         />
     </ nhibernate >
</ configuration >

上面的例子里用了SqlClient 驱动，在本地连接名称为NHibernate 的数据库，提供用户名和密码。那里有一堆属性你需要调整来确定如何让NHibernate来访问数据库。再次说明，你可以在文档里获取更多信息。

请注意以上的配置里并没有涉及到log4net的配置信息。NHibernate使用log4net来记录内部发生的一切。在一个应用程序产品里，在你特定环境里，我推荐配置log4net，并为NHibernate设置一定的日志级别。

第五步：开始展现NHibernate的魔力

所有艰苦的工作已经完成。你将有以下内容

User.cs ----你需要持久化的C#类

User.hbm.xml ----你的NHibernate映射文件

App.config ---对ADO.NET连接的配置信息（如果你愿意，你可以在代码中实现）。

你的数据库里有一张User表。

现在可以在你的代码中恰当简洁的使用NHibernate。简化的版本如下

创建一个Configuration对象

让Configuration知道你将存储何种类型的对象

为你选择的数据库创建一个Session对象

Load，Save和Query你的对象

通过Session的Flush()方法将对象提交给数据库。

为了让你更清晰，我们来看一些代码。

首先，创建一个Configuration对象

Configuration对象能够解析所有.Net对象和后台数据库中的映射关系。

Configuration cfg  =   new  Configuration();
cfg.AddAssembly( " NHibernate.Examples " );

Configuration对象会搜索装配件里的任何以hbm.xml 结尾的文件。还有其他方法加载映射文件，但这种方式是最简单的。

下一步，创建一个Session对象 ISession 对象提供一个到后台数据库的连接，ITransaction对象提供一个可以被NHibernate管理的事务。

ISessionFactory factory  =  cfg.BuildSessionFactory();
ISession session  =  factory.OpenSession();
ITransaction transaction  =  session.BeginTransaction();

接着来Load, Save和Query你的对象

现在你可以用使用传统的.Net方法来操纵对象。你想保存一个新对象到数据库吗？尝试下面的方法：

User newUser  =   new  User();
newUser.Id  =   " kim_cool " ;
newUser.UserName  =   " kimCool " ;
newUser.Password  =   " abc123 " ;
newUser.EmailAddress  =   " kim@cool.com " ;
newUser.LastLogon  =  DateTime.Now;
//  Tell NHibernate that this object should be saved
session.Save(newUser);
//  commit all of the changes to the DB and close the ISession
transaction.Commit();
session.Close();

正如你所看到的，关于NHiberante重要的事情是如此简单。继续并且查询你的数据库，验证一下User表里的新记录。现在重要的事情就是你去操心业务对象并在进行处理的时候告诉NHibernate就可以了。

让我们来告诉你，当你有一个UserID的时候如何获取对象（举例说，登陆你的网站的时候）。仅仅一句话就可以打开Session，传入key就可以了

session  =  factory.OpenSession();
User kimCool  =  (User)session.Load( typeof (User),  " kim_cool " );

你所获取的User对象还在生存周期内！改变它的属性，并通过Flush()持久化到数据库。

//  set kim Cool's Last Login property
kimCool.LastLogon  =  DateTime.Now;
//  flush the changes from the Session to the Database
session.Flush();

你所要做的就是通过NHibernate来进行你需要的改变，并调用Session的Flush()方法提交。验证一下数据库，查查用户ID为”kim_cool”的记录中”LastLogon”的更改。

还有更好的，你可以以System.Collections.IList的方式来获取从表中的对象。如下

IList userList  =  session.CreateCriteria( typeof (User)).List();
foreach (User user  in  userList)
{
    System.Diagnostics.Debug.WriteLine(user.Id  +   "  last logged in at  "   +  user.LastLogon);
}

这个查询将会返回所有表记录。往往你需要做更多的控制，比如说获取从8/19/ 2006 10:00 PM　以后登陆的用户，如下：

IList recentUsers  =  session.CreateCriteria( typeof (User))
    .Add(Expression.Expression.Gt( " LastLogon " ,  new  DateTime( 2006 ,  08 ,  19 ,  20 ,  0 ,  0 )))
    .List();
foreach (User user  in  recentUsers)
{
    System.Diagnostics.Debug.WriteLine(user.Id  +   "  last logged in at  "   +  user.LastLogon);
}

文档里还有一堆健壮的查询方式让你调用，这里仅仅让你对NHibernate所提供的强有力的工具有一定的了解。

最后调用Session对象的Close()方法，释放NHibernate所使用的ADO.Net连接资源

session.Close();