NHibernate - 快速指南

---

NHibernate - 概述

在本章中，我们将讨论NHibernate是什么、它可以在哪些平台上实现、它的优点是什么以及与之相关的其他方面。

什么是 NHibernate？

NHibernate 是一个成熟的、开源的.NET 框架对象关系映射器。它得到积极开发，功能齐全，并在数千个成功项目中使用。它构建在ADO.NET之上，当前版本是NHibernate 4.0.4。

• NHibernate 是一个开源 .NET 对象关系映射器，根据GNU Lesser General Public License分发。

• 它基于 Hibernate，Hibernate 是一种流行的 Java 对象关系映射器，并且拥有非常成熟和活跃的代码库。

• 它提供了一个将面向对象的域模型映射到传统关系数据库的框架。

• NHibernate 由Tom Barrett启动，该项目自 2003 年 2 月以来一直存在，这是他们的第一次提交。

• 这是一个大项目，提供了很多功能。

• 有一个可用的NuGet 包，这使得添加到项目中变得非常容易。

为什么选择NHibernate？

现在的问题是为什么我们需要对象关系映射器？这是因为对象世界和关系世界之间存在脱节。

• 在对象世界中，一切都是以对象为基础的；我们将那些拥有我们数据的东西称为对象。

• 关系世界都是基于集合的，我们处理的表和行与对象世界不同。

• 在对象世界中，我们有单向关联。如果客户有一个指向订单的指针，并不一定意味着订单有一个返回客户的指针，可能有也可能没有。

• 在关系世界中，所有关联都是双向的，并且可以通过外键来完成。

• 所有关联本质上都是双向的，因此当我们处理对象关系映射时，我们还需要处理这种脱节问题。

• 在对象世界中，我们使用的是单向的指针，而在关系世界中，我们使用本质上是双向的外键。

• 对象世界具有继承的概念，其中车辆可以有许多不同的子类，因此汽车是车辆的一种类型，船是车辆的一种类型，跑车是汽车的一种类型，这些类型继承关系。

• 关系世界没有继承的概念。

测绘

那么我们如何映射所有这些不相交的关系呢？这种映射的概念来自对象关系映射器。主要需要理解三件事，如下图所示。

• 在您的应用程序中，您将需要类定义，通常是 C# 代码及其表示我们的类的 .NET 代码，例如 Employee 类、Customer 类、Order 类等。

• 在底部，您可以看到一个数据库模式，这是我们在关系数据库中的数据定义语言，它指定了客户表的样子，员工表的样子。

• 在它们之间，我们有映射元数据，它告诉对象关系映射器如何根据行、列和外键关系从 C# 中的对象世界转换到数据库世界。

• 这种映射元数据可以用多种不同的方式表示，我们将研究 NHibernate 应用程序中最典型的多种不同方式。

• 它由HBM（Hibernate Mapping）文件表示，这些文件是 XML 文件。

支持数据库

NHibernate 支持多种不同的数据库。NHibernate 可以访问任何现有的关系数据库。

• SQL Server 是主要支持的数据库，这是大多数开发人员在开发过程中使用的数据库，它可能是最常见的数据库。

• 它也能很好地与 Oracle 配合使用。

• 它还支持 DB2、Firebird、MySQL、PostgreSQL、SQL Lite

• 它还具有ODBC 和 OLEDB 驱动程序。

NHibernate - 架构

如今，许多系统都是采用分层架构设计的，NHibernate 也拥有这种架构，并且与该设计完美配合。

分层架构

分层架构将系统分为多个组，每个组包含解决特定问题领域的代码，这些组称为层。大多数企业级应用程序使用由三层组成的高级应用程序架构-

• 表示层
• 业务层
• 持久层

例如，用户界面层（也称为表示层）可能包含用于构建网页和处理用户输入的所有应用程序代码。

分层方法的一个主要好处是，您通常可以对某一层进行更改，而不会对其他层造成任何重大干扰，从而使系统不那么脆弱且更易于维护。

表示层

• 它是最顶层，包含负责绘制用户界面、页面、对话框或屏幕、收集用户输入和控制导航的代码。

业务层

• 业务层负责实现用户理解为问题域一部分的任何业务规则或系统要求。

• 它还重用持久层定义的模型。

持久层

• 持久层由负责保存和检索应用程序数据的类和组件组成。

• 该层还定义了模型类和数据库之间的映射。NHibernate 主要用于这一层。

数据库

• 数据库存在于 .NET 应用程序之外。
• 它是系统状态的实际、持久的表示。
• 如果使用 SQL 数据库，则该数据库包括关系模式和可能的存储过程。

帮助程序/实用程序类

• 每个应用程序都有一组支持其他层的帮助程序或实用程序类：例如，UI 小部件、消息传递类、异常类和日志记录实用程序。

• 这些元素不被视为层，因为它们不遵守分层体系结构中层间依赖关系的规则。

NHibernate架构

• 它是 NHibernate 应用程序的高级视图，您还可以看到简单的 NHibernate 架构。

• 应用程序代码使用 NHibernate ISession和IQuery API 进行持久性操作，并且只需管理数据库事务，最好使用 NHibernate ITransaction API。

NHibernate-ORM

在我们真正开始使用 NHibernate 之前，我们需要了解它的构建基础。NHibernate 是一种基于对象关系映射或 ORM 思想的持久性技术。

什么是 ORM？

对象关系映射 (ORM) 是一种编程技术，用于在面向对象编程语言中的不兼容类型系统之间转换数据。换句话说，它是将应用程序的业务对象映射到关系数据库表的概念，以便完全通过应用程序的对象模型轻松访问和更新数据。

• 您已经知道，关系数据库提供了一种存储数据的好方法，而面向对象编程是构建复杂应用程序的好方法。

• NHibernate 和 ORM 通常与具有重要业务逻辑、领域模型和某种数据库的应用程序最相关。

• 使用 ORM，可以非常轻松地创建一个转换层，可以轻松地将对象转换为关系数据，然后再转换回来。

• 缩写词 ORM 也可以表示对象角色建模，这个术语是在对象/关系映射变得相关之前发明的。

• 它描述了一种用于数据库建模的信息分析方法。

为什么是 ORM？

ORM 是一个框架，使您能够将面向对象语言中的对象世界映射到关系数据库中的关系表中的行

为了理解这个概念，让我们看一下下图。

• 在上图中，您可以看到右侧有一个名为 Employee 的表，其中包含与单个员工关联的每条数据的列。

• 我们有一个 ID 列，它唯一地标识每个员工。

• 一列显示员工姓名，另一列显示其加入日期，最后一列显示员工的年龄。

• 如果我们想编写一些代码来将新员工存储在表中，那就不是那么容易了。

• 在上图中，您还可以看到我们有一个员工对象，其中包含 ID、姓名、加入日期和年龄字段。

• 如果没有 ORM，我们必须将此对象转换为几个不同的 SQL 语句，将员工数据插入到员工表中。

• 因此，编写代码来创建 SQL 来执行上述场景并不难，但有点乏味且很容易出错。

• 使用像 NHibernate 这样的 ORM，我们可以声明某些类应该如何映射到关系表，并让 ORM 或 NHibernate 处理创建 SQL 来插入、更新、删除我们的员工表中的查询数据的繁琐工作。

• 这使我们能够将代码集中在使用对象上，并将这些对象自动转换为关系表。

• 因此，ORM 的真正作用是让我们不必手动将对象映射到表。

NHibernate - 环境设置

要开始使用 NHibernate，我们需要 Visual Studio 和 NHibernate 包。

视觉工作室安装

Microsoft 提供了Visual Studio 的免费版本，其中还包含SQL Server，可以从 https://www.visualstudio.com下载以下是安装步骤。

步骤 1 - 下载完成后运行安装程序，然后将显示以下对话框。

步骤 2 - 单击“安装”按钮，它将开始安装过程。

步骤 3 - 安装过程成功完成后，您将看到以下对话框。

步骤 4 - 关闭此对话框并根据需要重新启动计算机。

步骤 5 - 现在从“开始”菜单打开 Visual studio，这将打开以下对话框。第一次需要一些时间准备。

步骤 6 - 完成所有这些后，您将看到 Visual Studio 的主窗口。

NHibernate 包安装

NHibernate 是一个成熟的、开源的.NET 框架对象关系映射器。它得到积极开发，功能齐全，并在数千个成功项目中使用。您可以使用以下方法安装NHibernate包。

直接下载

• 从https://sourceforge.net/下载 zip 文件，其中包含所需的所有二进制文件。

• 解压缩此 zip 文件并将所有这些二进制文件包含在您的项目中。

使用 NuGet 安装

• 安装 NHibernate 的另一种方法是使用 NuGet 安装 NHibernate 包，这是迄今为止将 NHibernate 合并到项目中的最简单方法。

• 它将下载所有 NHibernate 依赖项并创建对所有必需程序集的引用。

• 要安装 NHibernate，请在程序包管理器控制台中运行以下命令。

install-package NHibernate

您现在可以开始申请了。

NHibernate - 入门

在本章中，我们将了解如何使用 NHibernate 启动一个简单的示例。我们将构建一个简单的控制台应用程序。为了创建控制台应用程序，我们将使用 Visual Studio 2015，它包含创建、使用 NHibernate 包测试您的应用程序所需的所有功能。

以下是使用 Visual Studio 中提供的项目模板创建项目的步骤。

步骤 1 - 打开 Visual Studio 并单击“文件”→“新建”→“项目”菜单选项。

步骤 2 - 将打开一个新的项目对话框。

步骤 3 - 从左侧窗格中，选择模板 → Visual C# → Windows。

步骤 4 - 在中间窗格中，选择控制台应用程序。

步骤 5 - 在“名称”字段中输入项目名称“NHibernateDemoApp”，然后单击“确定”继续。

步骤 6 - Visual Studio 创建项目后，您将看到解决方案资源管理器窗口中显示许多文件。

如您所知，我们已经创建了一个简单的控制台应用程序项目，现在我们需要将 NHibernate 包包含到我们的控制台项目中。

转到“工具”菜单并选择“NuGet 包管理器”→“包管理器控制台”，它将打开“包管理器控制台”窗口。

指定上面的包管理器控制台窗口中显示的命令并按 Enter 键，它将下载所有 NHibernate 依赖项并创建对所有必需程序集的引用。安装完成后，您将看到如下图所示的消息。

现在我们已经添加了NHibernate，我们现在可以开始实施了。因此，我们首先映射一个名为Student的非常简单的表，该表只有一个名为 ID 的整数主键以及一个 FirstName 和 LastName 列。

我们需要一个类来代表该学生，因此让我们创建一个名为 Student 的新类，方法是右键单击解决方案资源管理器中的项目，然后选择“添加”→“类”，这将打开“添加新项”对话框。

在名称字段中输入Student.cs，单击“添加”按钮。在这个 Student 类中，我们需要有一个名为 ID 的整数主键，并且需要创建这个字符串、FirstName和LastName字段，如以下 Student 类的完整实现所示。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks;

namespace NHibernateDemoApp { 
   
   class Student { 
      public virtual int ID { get; set; } 
      public virtual string LastName { get; set; } 
      public virtual string FirstMidName { get; set; } 
   } 
}

当处理 NHibernate 应用程序中的模型时，最简单的方法是将所有字段虚拟化。这是我们将使用的简单 NHibernate 模型，并将其映射到后端数据库。

现在让我们转到 Program 类中的 Main 方法并创建一个新的 NHibernate 配置对象。

我们需要提供的第一件事是连接字符串。这是数据库特定的连接字符串，查找连接字符串的最简单方法是在SQL Server 对象资源管理器中右键单击数据库并选择“属性”。

它将打开“属性”窗口，现在向下滚动，您将在“属性”窗口中看到“连接字符串”字段。

复制连接字符串并在代码中指定。以下是 Main 方法的实现，其中我们需要配置 NHibernate。

using NHibernate.Cfg;
using NHibernate.Dialect;
using NHibernate.Driver;

using System;
using System.Linq;
using System.Reflection;

namespace NHibernateDemoApp {

   class Program {
   
      static void Main(string[] args) {
         var cfg = new Configuration();
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;
			
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover";
         
                     
            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>();
         });
         
         cfg.AddAssembly(Assembly.GetExecutingAssembly());
         
         var sefact = cfg.BuildSessionFactory(); 
         
         using (var session = sefact.OpenSession()) {
         
            using (var tx = session.BeginTransaction()) {
               //perform database logic 
               tx.Commit();
            }
            
            Console.ReadLine(); 
         } 
      } 
   } 
}

在连接字符串之后，我们需要提供一个驱动程序，即 SQLClientDriver ，然后我们还需要为其提供一个方言，即 SQL Server 的版本，我们将使用 MS SQL 2008。

NHibernate 现在知道如何连接到数据库。我们需要做的另一件事是为其提供我们将映射的模型列表。

我们可以通过添加程序集来做到这一点，因此通过指定 Assembly.GetExecutingAssembly ，这就是程序将找到映射文件的位置。映射文件告诉 NHibernate 如何从 C# 类进入数据库表。

SessionFactory 编译初始化 NHibernate 所需的所有元数据。SessionFactory可用于构建会话，大致类似于数据库连接。所以合适的方法是在using块中使用它。我可以说var session等于sessionFactory.OpenSession并且我想在其事务内部执行此操作。

一旦会话打开，我们就可以告诉会话开始一个新事务，然后我们可以在这里执行一些逻辑。因此，执行一些数据库逻辑并最终提交该事务。

NHibernate - 基本 ORM

在本章中，我们将介绍一些基本映射，并且从上一章中您知道我们有数据库表以及 C# 类定义。我们现在需要一个映射来解释如何在 C# 和数据库之间进行转换。

因此，让我们继续添加一个新的 XML 文件，方法是右键单击解决方案资源管理器中的项目，然后选择“添加”→“新项目...”

在名称字段中输入Student.hbm.xml 。我们需要指定一个默认程序集 NHibernateDemoApp并指定一个默认命名空间。这只是缩短了我们要在此文件中进行的许多其他类型定义。

以下是 XML 文件中的实现 -

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

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

   <class name = "Student"> 
      <id name = "ID">
        <generator class = "native"/> 
      </id> 
		
      <property name = "LastName"/> 
      <property name = "FirstMidName"/> 
   </class> 
   
</hibernate-mapping>

接下来我们需要定义一个类；这个班级将是我们的学生班级。接下来，我们需要告诉 NHibernate id 的名称，即 ID，我还必须告诉 NHibernate 如何生成 ID，因此我们的生成器将是 native 类型。

本机类型生成器意味着在 SQL Server 这样的数据库中，它将使用标识列，即标识类型。

接下来我们要做的就是给出属性的名称。因此，为 FirstName 和 LastName 添加两个属性。

现在，我们正在从程序集中读取这些映射文件。因此，首选方法是将这些HBM 文件烘焙到程序集中。我们可以通过简单地设置一个属性来做到这一点。

现在，右键单击解决方案资源管理器中的项目并选择“属性”，您将看到“生成操作”字段，其中默认选择“内容”。

从下拉列表中选择嵌入资源。

因此，这实际上将该 XML 文件嵌入到NHibernateDemoApp程序集中。

NHibernate - 基本 CRUD 操作

在本章中，我们将介绍基本的CRUD 操作。现在我们的系统已准备好启动，因为我们已经成功实现了我们的域 Student 类，我们还定义了映射文件并配置了 NHibernate。我们现在可以使用一些查询来执行 CRUD 操作。

创建数据

正如您所看到的， NHibernateDemoDB数据库中的 Student 表中没有数据。

因此，要添加一些数据，我们需要执行添加/创建操作，如下所示。

using (var session = sefact.OpenSession()) { 

   using (var tx = session.BeginTransaction()) { 
     
      var student1 = new Student { 
         ID = 1, 
         FirstMidName = "Allan", 
         LastName = "Bommer" 
      }; 
      
      var student2 = new Student { 
         ID = 2, 
         FirstMidName = "Jerry", 
         LastName = "Lewis" 
      }; 
      
      session.Save(student1); 
      session.Save(student2); 
      tx.Commit(); 
   } 
   
   Console.ReadLine(); 
}

正如你所看到的，我们创建了两个学生，然后调用OpenSession的 Save() 方法，然后调用BeginTransaction的 Commit() 方法。这是Program.cs文件中的完整实现

using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection;

namespace NHibernateDemoApp { 
   
   class Program { 
      
      static void Main(string[] args) { 
         var cfg = new Configuration();
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;
			
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 

            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>(); 
         }); 
   
         cfg.AddAssembly(Assembly.GetExecutingAssembly()); 
         var sefact = cfg.BuildSessionFactory(); 
			
         using (var session = sefact.OpenSession()) { 
			
            using (var tx = session.BeginTransaction()) { 
               
               var student1 = new Student { 
                  ID = 1,  
                  FirstMidName = "Allan", 
                  LastName = "Bommer" 
               }; 

               var student2 = new Student { 
                  ID = 2, 
                  FirstMidName = "Jerry", 
                  LastName = "Lewis" 
               }; 
            
               session.Save(student1); 
               session.Save(student2); 
               tx.Commit();
            } 
            
            Console.ReadLine(); 
         } 
      } 
   } 
}

现在让我们运行这个应用程序，然后转到 SQL Server 对象资源管理器并刷新数据库。您将看到上面的两个学生现在已添加到 NHibernateDemoDB 数据库的 Student 表中。

从学生表中读取数据

您可以看到现在学生表中有两条记录。要从表中读取这些记录，我们需要调用OpenSession 的CreateCriteria()，如以下代码所示。

using (var session = sefact.OpenSession()) { 
   
   using (var tx = session.BeginTransaction()) { 
      var students = session.CreateCriteria<Student>().List<Student>(); 
      
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", 
            student.ID,student.FirstMidName, student.LastName); 
      } 
      
      tx.Commit(); 
   } 
   
   Console.ReadLine(); 
}

因此，如果您想要记录列表，那么我们可以简单地说“学生”类型的列表。

现在对所有学生使用foreach并在控制台上打印 ID、 FirstMidName和LastName 。现在，让我们再次运行该应用程序，您将在控制台窗口上看到以下输出。

1 Allan Bommer
2 Jerry Lewis

您还可以使用以下代码通过在 OpenSession 的Get()方法中指定 ID 来检索任何记录。

using (var session = sefact.OpenSession()) { 
   
   using (var tx = session.BeginTransaction()) { 
      var students = session.CreateCriteria<Student>().List<Student>(); 
      
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", student.ID, 
            student.FirstMidName, student.LastName); 
      }
      
      var stdnt = session.Get<Student>(1); 
      Console.WriteLine("Retrieved by ID"); 
      Console.WriteLine("{0} \t{1} \t{2}", stdnt.ID, 
         stdnt.FirstMidName, stdnt.LastName); 
      tx.Commit();
   } 
	
   Console.ReadLine(); 
}

现在，当您运行应用程序时，您将看到以下输出。

1 Allan Bommer
2 Jerry Lewis
Retrieved by ID
1 Allan Bommer

更新记录

要更新表中的记录，我们需要首先获取该特定记录，然后通过调用OpenSession 的Update()方法来更新该记录，如以下代码所示。

using (var session = sefact.OpenSession()) { 

   using (var tx = session.BeginTransaction()) { 
      var students = session.CreateCriteria<Student>().List<Student>(); 
     
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", student.ID, 
            student.FirstMidName, student.LastName); 
      }
      
      var stdnt = session.Get<Student>(1); 
      Console.WriteLine("Retrieved by ID"); 
      Console.WriteLine("{0} \t{1} \t{2}", stdnt.ID, stdnt.FirstMidName, stdnt.LastName);
      
      Console.WriteLine("Update the last name of ID = {0}", stdnt.ID); 
      stdnt.LastName = "Donald"; 
      session.Update(stdnt); 
      Console.WriteLine("\nFetch the complete list again\n"); 
      
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", student.ID, 
            student.FirstMidName, student.LastName); 
      } 
      
      tx.Commit();
   } 
   
   Console.ReadLine();
}

现在，当您运行应用程序时，您将看到以下输出。

1 Allan Bommer
2 Jerry Lewis
Retrieved by ID
1 Allan Bommer
Update the last name of ID = 1
Fetch the complete list again
1 Allan Donald
2 Jerry Lewis

如您所见，ID 等于 1 的 LastName 从 Bommer 更新为 Donald。

删除记录

要从表中删除任何记录，我们需要首先获取该特定记录，然后通过调用OpenSession 的Delete()方法删除该记录，如以下代码所示。

using (var session = sefact.OpenSession()) { 
   
   using (var tx = session.BeginTransaction()) { 
      var students = session.CreateCriteria<Student>().List<Student>();
      
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", student.ID, 
            student.FirstMidName, student.LastName); 
      }
      
      var stdnt = session.Get<Student>(1); 
      Console.WriteLine("Retrieved by ID"); 
      Console.WriteLine("{0} \t{1} \t{2}", stdnt.ID, stdnt.FirstMidName, stdnt.LastName);
      
      Console.WriteLine("Delete the record which has ID = {0}", stdnt.ID); 
      session.Delete(stdnt);
      Console.WriteLine("\nFetch the complete list again\n"); 
      
      foreach (var student in students) { 
         Console.WriteLine("{0} \t{1} \t{2}", student.ID, student.FirstMidName, 
            student.LastName); 
      } 
      
      tx.Commit();
   } 
	
   Console.ReadLine(); 
}

现在，当您运行应用程序时，您将看到以下输出。

1 Allan Donald
2 Jerry Lewis
Retrieved by ID
1 Allan Bommer
Delete the record which has ID = 1
Fetch the complete list again
2 Jerry Lewis

正如您所看到的，ID 等于 1 的记录在数据库中不再可用。您还可以在 SQL Server 对象资源管理器中查看数据库。

NHibernate - 分析器

在本章中，我们将了解如何检索、更新、创建和删除数据库中的所有记录，以及这些查询到底是如何执行的？

要了解所有这些，我们可以简单地在配置中添加一个选项，该选项将 SQL 记录在控制台中。下面是记录 SQL 查询的简单语句 -

x.LogSqlInConsole = true;

现在，NHibernateDemoDB 数据库中的学生表中有两条记录。让我们从数据库中检索所有记录，如以下代码所示。

using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection;

namespace NHibernateDemoApp { 

   class Program { 
      
      static void Main(string[] args) { 
         var cfg = new Configuration();
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;			
         
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 
            
            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>(); 
            x.LogSqlInConsole = true; 
         }); 
      
         cfg.AddAssembly(Assembly.GetExecutingAssembly()); 
         var sefact = cfg.BuildSessionFactory();
      
         using (var session = sefact.OpenSession()) { 
         
            using (var tx = session.BeginTransaction()) { 
               Console.WriteLine("\nFetch the complete list again\n");
               var students = session.CreateCriteria<Student>().List<Student>(); 
      
               foreach (var student in students) { 
                  Console.WriteLine("{0} \t{1} \t{2}", student.ID, student.FirstMidName,
                     student.LastName); 
               } 
               
               tx.Commit(); 
            } 
				
            Console.ReadLine(); 
         } 
      } 
   } 
}

因此，让我们再次运行该应用程序，您将看到以下输出 -

NHibernate: SELECT this_.ID as ID0_0_, this_.LastName as LastName0_0_,
   this_.FirstMidName as FirstMid3_0_0_ FROM Student this_

Fetch the complete list again

3 Allan Bommer
4 Jerry Lewis

正如您所看到的，select 子句被发送到数据库，它实际上类似于将检索 ID、FirstMidName 和 LastName 的子句。因此，所有这些都被发送到数据库并在那里进行处理，而不是将大量记录带回服务器并在服务器端进行处理。

NHibernate 分析器

查看这些结果的另一种方法是使用 NHibernate Profiler。NHibernate Profiler 是一个商业工具，但它对于处理 NHibernate 应用程序非常有用。您可以轻松地从 NuGet 将 NHibernate Profiler 安装到您的应用程序中。

让我们通过选择 NuGet Package Manager → Package Manager Console 从“工具”菜单转到 NuGet Manager 控制台。它将打开包管理器控制台窗口。输入以下命令并按 Enter 键。

PM> install-package NHibernateProfiler

它将安装 NHibernate Profiler 所需的所有二进制文件，成功安装后您将看到以下消息。

安装后，您还将看到 NHibernate Profiler 已启动。它需要许可证才能使用，但出于演示目的，我们可以使用 NHibernate Profiler 的 30 天试用版。

现在，NHibernate Profiler 已针对 Web 应用程序进行了优化，您将看到它在解决方案资源管理器中添加了App_Start 文件夹。为了使所有这些简单，请删除 App_Start 文件夹，您还会发现在 Program 类的 Main 方法的开头添加了一条语句。

App_Start.NHibernateProfilerBootstrapper.PreStart();

也删除此语句，仅添加一个简单的调用NHibernateProfiler.Initialize，如以下代码所示。

using HibernatingRhinos.Profiler.Appender.NHibernate; 
using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection;

namespace NHibernateDemoApp { 
   
   class Program { 
	
      static void Main(string[] args) { 
		
         NHibernateProfiler.Initialize(); 
         var cfg = new Configuration();
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;			
         
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover";
				
            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>(); 
            x.LogSqlInConsole = true; 
         }); 

         cfg.AddAssembly(Assembly.GetExecutingAssembly()); 
         var sefact = cfg.BuildSessionFactory(); 
         
         using (var session = sefact.OpenSession()) { 
            
            using (var tx = session.BeginTransaction()){ 
               var students = session.CreateCriteria<Student>().List<Student>(); 
               Console.WriteLine("\nFetch the complete list again\n");
               
               foreach (var student in students) { 
                  Console.WriteLine("{0} \t{1} \t{2}", student.ID, student.FirstMidName,
                     student.LastName); 
               } 
					
               tx.Commit(); 
            } 
				
            Console.ReadLine(); 
         } 
      } 
   
   }
}

现在，当您运行该应用程序时，它会将数据发送到 NHibernate Profiler 应用程序。

您可以在这里看到，我们有一个很好的显示，显示我们已经开始事务，SQL 以良好的格式对数据库做了什么。

因此，这对于确定 NHibernate 应用程序内部到底发生了什么非常有用。一旦应用程序达到一定程度的复杂性，您需要更像 SQL Profiler 的东西，但需要了解 NHibernate，那么它就会变得非常有用。

将 Intelliesnse 添加到映射文件

在本章中，我们将把IntelliSense添加到 NHibernate 映射文件（*.hbm.xml 文件）中。正如您在映射域 Student 类时所观察到的，目前我们没有可用的 IntelliSense。拥有可用的XML 模式非常有用。因此，在本章中，您将了解如何在 Visual Studio 中为这些 NHibernate XML 文件添加 IntelliSense。

打开映射文件，您将看到主菜单中出现 XML 菜单选项。

选择 XML → Schemas… 菜单选项，它将显示 XML Schemas 对话框。

选择对话框右上角的“添加...”按钮，这将打开文件对话框。现在转到packages 文件夹，该文件夹位于项目的 Solution 文件夹中，您将看到项目中包含的不同包。

现在，双击NHibernate.4.*** 文件夹，您将看到两个模式 (*.xsd) 文件或定义 NHibernate 配置和映射的 XML 模式定义文件。

选择这两个模式文件并单击“打开”按钮。

您可以看到 NHibernate 模式已添加到 XML 模式对话框中。单击“确定”按钮。现在，让我们开始一个新的属性标签，您将看到我们在这里拥有完整的 IntelliSense。

现在，您可以使用 IntelliSense，这可以在对象关系映射过程中节省大量时间。

NHibernate - 数据类型映射

在本章中，我们将讨论映射数据类型。映射实体很简单，实体类始终使用<class>、<subclass> 和 <joined-subclass>映射元素映射到数据库表。值类型还需要更多东西，这就是需要映射类型的地方。

NHibernate 能够映射多种数据类型。以下是支持的最常见数据类型的列表。

上面给出的表格详细解释了下面提到的指针。

• 从简单的数字类型到字符串，可以使用varchar、char等以多种方式映射，以及字符串 blob 和数据库支持的所有类型。

• 它还能够将布尔值映射到使用零和一的字段、包含 true、false 或 T 和 F 的字符字段。

• 有多种方法可以定义如何映射到后端数据库中的布尔值。

• 我们可以处理DateTime的映射，包括和排除时区偏移、夏令时等。

• 我们还可以映射枚举；我们可以将它们映射到字符串或其基础数值。

让我们看一个简单的示例，其中数据库和 Student 类中都有相同的属性名称。

现在让我们在学生类中将 FirstMidName 更改为 FirstName，其中我们不会更改 FirstMidName 列，但我们将了解如何告诉 NHibernate 知道执行此转换。以下是更新后的学生班级。

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks;

namespace NHibernateDemoApp { 
  
   class Student { 
      public virtual int ID { get; set; } 
      public virtual string LastName { get; set; } 
      public virtual string FirstName { get; set; } 
   }
}

这里是NHibernate映射文件的实现。

<?xml version = "1.0" encoding = "utf-8" ?> 
<hibernate-mapping xmlns = "urn:nhibernate-mapping-2.2" assembly = "NHibernateDemoApp" 
   namespace = "NHibernateDemoApp"> 
   
   <class name = "Student">
	
      <id name = "ID"> 
         <generator class = "native"/>
      </id> 
   
      <property name = "LastName"/> 
      <property name = "FirstName" column = "FirstMidName" type = "String"/> 
   </class> 

</hibernate-mapping>

在此示例中，假设 FirstName 字段是 .NET 字符串，FirstMidName 列是SQL nvarchar。现在要告诉 NHibernate 如何执行此转换，请将名称设置为FirstName，将列设置为FirstMidName，并指定映射类型等于 String，这适合此特定转换。

以下是Program.cs文件的实现。

using HibernatingRhinos.Profiler.Appender.NHibernate; 
using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection;

namespace NHibernateDemoApp { 

   class Program { 
	
      static void Main(string[] args) { 
		
         NHibernateProfiler.Initialize(); 
         var cfg = new Configuration(); 
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;
         
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 
            
            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>(); 
            x.LogSqlInConsole = true; 
         }); 
         
         cfg.AddAssembly(Assembly.GetExecutingAssembly()); 
         var sefact = cfg.BuildSessionFactory();
			
         using (var session = sefact.OpenSession()) { 
            
            using (var tx = session.BeginTransaction()) { 
               var students = session.CreateCriteria<Student>().List<Student>(); 
               Console.WriteLine("\nFetch the complete list again\n"); 
               
               foreach (var student in students) { 
                  Console.WriteLine("{0} \t{1} \t{2}", student.ID, student.FirstName,
                     student.LastName); 
               } 
					
               tx.Commit(); 
            } 
				
            Console.ReadLine(); 
         } 
      } 
   }
}

现在，当您运行应用程序时，您将看到以下输出。

NHibernate: SELECT this_.ID as ID0_0_, this_.LastName as LastName0_0_, 
   this_.FirstMidName as FirstMid3_0_0_ FROM Student this_

Fetch the complete list again
3 Allan Bommer
4 Jerry Lewis

正如您所看到的，它已将不同的属性名称映射到数据库中的列名称。

让我们看另一个例子，我们将在枚举类型的 Student 类中添加另一个属性。这是 Student 类的实现。

using System; 
using System.Collections.Generic; 
using System.Linq; using System.Text; 
using System.Threading.Tasks; 

namespace NHibernateDemoApp { 
   
   class Student { 
      public virtual int ID { get; set; } 
      public virtual string LastName { get; set; } 
      public virtual string FirstName { get; set; } 
      public virtual StudentAcademicStanding AcademicStanding { get; set; } 
   } 
   
   public enum StudentAcademicStanding { 
      Excellent, 
      Good, 
      Fair, 
      Poor, 
      Terrible 
   } 
}

正如您所看到的，枚举具有多种不同的值，例如 Excellent、Good、Fair、Poor 和 Terrible。

跳转到映射文件，您可以看到每个属性都在映射文件中列出，包括新添加的AcademicStanding属性。

<?xml version = "1.0" encoding = "utf-8" ?> 
<hibernate-mapping xmlns = "urn:nhibernate-mapping-2.2" 
   assembly = "NHibernateDemoApp" namespace = "NHibernateDemoApp"> 
   
   <class name = "Student"> 
	
      <id name = "ID"> 
         <generator class = "native"/> 
      </id> 

      <property name = "LastName"/> 
      <property name = "FirstName" column = "FirstMidName" type = "String"/> 
      <property name = "AcademicStanding"/> 
   </class>  

</hibernate-mapping>

现在我们还需要更改数据库，因此转到 SQL Server 对象资源管理器并右键单击数据库并选择“新建查询...”选项。

它将打开查询编辑器，然后指定以下查询。

DROP TABLE [dbo].[Student]

CREATE TABLE [dbo].[Student] ( 
   [ID] INT IDENTITY (1, 1) NOT NULL, 
   [LastName] NVARCHAR (MAX) NULL, 
   [FirstMidName] NVARCHAR (MAX) NULL, 
   [AcademicStanding] NCHAR(10) NULL, 
   CONSTRAINT [PK_dbo.Student] PRIMARY KEY CLUSTERED ([ID] ASC) 
);

该查询将首先删除现有的学生表，然后创建一个新表。

单击“执行”图标，如上所示。查询成功执行后，您会看到一条消息。

展开数据库和表下拉列表，然后右键单击 Student 表并选择视图设计器。

现在，您将看到新创建的表，它还具有新属性AcademicStanding。

让我们添加两条记录，如以下Program.cs文件中所示。

using HibernatingRhinos.Profiler.Appender.NHibernate; 
using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection;

namespace NHibernateDemoApp { 

   class Program { 
      
      static void Main(string[] args) { 
		
         NHibernateProfiler.Initialize(); 
         var cfg = new Configuration(); 
			
         String Data Source = asia13797\\sqlexpress;
         String Initial Catalog = NHibernateDemoDB;
         String Integrated Security = True;
         String Connect Timeout = 15;
         String Encrypt = False;
         String TrustServerCertificate = False;
         String ApplicationIntent = ReadWrite;
         String MultiSubnetFailover = False;
         
         cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
            Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
            TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 
            
            x.Driver<SqlClientDriver>(); 
            x.Dialect<MsSql2008Dialect>(); 
         }); 
         
         cfg.AddAssembly(Assembly.GetExecutingAssembly()); 
         var sefact = cfg.BuildSessionFactory(); 
         
         using (var session = sefact.OpenSession()) { 
            using (var tx = session.BeginTransaction()) { 
               
               var student1 = new Student { 
                  ID = 1, 
                  FirstName = "Allan", 
                  LastName = "Bommer",
                  AcademicStanding = StudentAcademicStanding.Excellent 
               };
               
               var student2 = new Student { 
                  ID = 2, 
                  FirstName = "Jerry", 
                  LastName = "Lewis", 
                  AcademicStanding = StudentAcademicStanding.Good 
               };
					
               session.Save(student1); 
               session.Save(student2);
               var students = session.CreateCriteria<Student>().List<Student>(); 
               Console.WriteLine("\nFetch the complete list again\n");
               
               foreach (var student in students) { 
                  Console.WriteLine("{0} \t{1} \t{2} \t{3}", student.ID,
                     student.FirstName, student.LastName, student.AcademicStanding); 
               } 
					
               tx.Commit(); 
            }
				
            Console.ReadLine(); 
         } 
      } 
   } 
}

现在让我们运行您的应用程序，您将在控制台窗口上看到以下输出。

Fetch the complete list again

1 Allan Bommer Excellent
2 Jerry Lewis Good

现在让我们通过右键单击“学生表”来查看数据库。

选择“查看数据”，您将看到学生表中的两条记录，如下图所示。

您可以看到添加了两条记录，Allan 的AcademicStanding 为0，Jerry 的AcademicStanding 1。这是因为在.Net 中，默认情况下第一个枚举值是0，如果您查看StudentAcademicStanding ，这非常好。而在 Student.cs 文件中 Good 是第二个，因此它的值为 1。

NHibernate - 配置

在本章中，我们将了解 NHibernate 配置。我们有不同的方法来配置 NHibernate。它分为两个主要组

• 基于 XML 的配置
• 基于代码的配置

基于代码的配置

基于代码的配置内置于 NHibernate 中。它是在 NHibernate 3 周围引入的，到目前为止我们已经使用了代码库配置。

String Data Source = asia13797\\sqlexpress;
String Initial Catalog = NHibernateDemoDB;
String Integrated Security = True;
String Connect Timeout = 15;
String Encrypt = False;
String TrustServerCertificate = False;
String ApplicationIntent = ReadWrite;
String MultiSubnetFailover = False;

cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
   Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
   TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 
   
   x.Driver<SqlClientDriver>(); 
   x.Dialect<MsSql2008Dialect>(); 
   x.LogSqlInConsole = true; 
}); 

cfg.AddAssembly(Assembly.GetExecutingAssembly());

所有配置均在 C# 代码中指定。您可以在这里看到我们已经获得了新的配置对象，然后我们使用NHibernate 3.1 引入的loquacious 配置来配置数据库。我们正在使用什么连接字符串，我们正在连接到什么数据库以及要使用的方言。我们还将映射程序集直接添加到此处。

基于 XML 的配置

如果您使用基于 XML 的配置，则可以使用hibernate.cfg.xml文件，该文件只是使用 NHibernate 架构的独立 xml 文件，或者您可以将该 NHibernate 特定配置嵌入到您的 app 或web.cfg中。hibernate.cfg.xml 名称是默认名称，但我们也可以为该 xml 文件使用任意名称。

让我们通过向 NHibernateDemoApp 项目添加一个新的 xml 文件并将其命名为 hibernate.cfg.xml 来了解基于 XML 的配置。

将以下信息输入到 hibernate.cfg.xml 文件中。

<?xml version = "1.0" encoding = "utf-8" ?> 
<hibernate-configuration xmlns = "urn:nhibernate-configuration-2.2"> 
   <session-factory> 
   
      <property name = "connection.connection_string">
         Data Source = asia13797\\sqlexpress;
         Initial Catalog = NHibernateDemoDB;
         Integrated Security = True;
         Connect Timeout = 15;
         Encrypt = False;
         TrustServerCertificate = False;
         ApplicationIntent = ReadWrite;
         MultiSubnetFailover = False;
      </property> 
      
      <property name = "connection.driver_class">
         NHibernate.Driver.SqlClientDriver
      </property> 
		
      <property name = "dialect">
         NHibernate.Dialect.MsSql2008Dialect
      </property> 
		
      <mapping assembly = "NHibernateDemoApp"/>
		
   </session-factory> 
	
</hibernate-configuration>

正如您在上面的 xml 文件中看到的，我们指定了与 C# 中提到的相同配置。

现在让我们在 Program.cs 文件中对此配置进行评论，并调用Configure()方法，该方法将加载hibernate.cfg.xml文件，如下所示。

using HibernatingRhinos.Profiler.Appender.NHibernate; 
using NHibernate.Cfg; 
using NHibernate.Dialect; 
using NHibernate.Driver; 

using System; 
using System.Linq; 
using System.Reflection; 

namespace NHibernateDemoApp { 

   class Program { 
      
      static void Main(string[] args) { 
		
         NHibernateProfiler.Initialize(); 
         var cfg = new Configuration(); 
         
         //cfg.DataBaseIntegration(x =>
         
         //{ 
            // x.ConnectionString = "Data Source = asia13797;\\sqlexpress
            Initial Catalog = NHibernateDemoDB;
            Integrated Security = True;
            Connect Timeout = 15;
            Encrypt =False;
            TrustServerCertificate = False;
            ApplicationIntent = ReadWrite;
            MultiSubnetFailover = False"; 
            
            // x.Driver<SqlClientDriver>(); 
            // x.Dialect<MsSql2008Dialect>(); 
            // x.LogSqlInConsole = true; 
         //}); 
         
         //cfg.AddAssembly(Assembly.GetExecutingAssembly());
         cfg.Configure();
         var sefact = cfg.BuildSessionFactory();
			
         using (var session = sefact.OpenSession()) { 
            
            using (var tx = session.BeginTransaction()) { 
               var students = session.CreateCriteria<Student>().List<Student>(); 
               Console.WriteLine("\nFetch the complete list again\n"); 
               
               foreach (var student in students) { 
                  Console.WriteLine("{0} \t{1} \t{2} \t{3}", student.ID,
                     student.FirstName, student.LastName, student.AcademicStanding); 
               } 
					
               tx.Commit(); 
            } 
				
            Console.ReadLine(); 
         } 
      } 
   } 
}

让我们再次运行您的应用程序，您将看到相同的输出。

Fetch the complete list again

1 Allan Bommer Excellent
2 Jerry Lewis Good

NHibernate - 覆盖配置

在本章中，我们将介绍如何覆盖 NHibernate 配置。您需要记住几件事。

• 首先，NHibernate 中的配置是附加的。

• 因此，您不必只使用单个 xml 文件，也不必只使用基于代码的配置或流畅的 NHibernate。

• 您可以根据您想要如何配置应用程序来混合和匹配所有这些方法。

• 要记住的重要一点是，最终配置获胜。

在下面的示例中，您可以看到我们创建了配置对象，使用基于代码的配置对其进行配置，最后调用 cfg.configure ()方法，该方法加载 hibernate.cfg.xml 文件。

String Data Source = asia13797\\sqlexpress;
String Initial Catalog = NHibernateDemoDB;
String Integrated Security = True;
String Connect Timeout = 15;
String Encrypt = False;
String TrustServerCertificate = False;
String ApplicationIntent = ReadWrite;
String MultiSubnetFailover = False;

cfg.DataBaseIntegration(x = > { x.ConnectionString = "Data Source + 
   Initial Catalog + Integrated Security + Connect Timeout + Encrypt +
   TrustServerCertificate + ApplicationIntent + MultiSubnetFailover"; 
	
   x.Driver<SqlClientDriver>(); 
   x.Dialect<MsSql2008Dialect>(); 
   x.LogSqlInConsole = true; 
}); 

cfg.Configure();

• 因此 hibernate.cfg.xml 中的任何内容都会覆盖基于代码的配置设置的设置。

• 通过反转这两个过程，我们可以在 hibernate.cfg.xml 中使用默认值，然后在基于代码的配置中进行覆盖。

• 如果您使用基于代码的配置，则没有什么可以排除的，也没有什么可以阻止您使用 hibernate.cfg.xml 文件。

让我们看一个简单的示例，在该示例中我们将混合使用基于 xml 和基于代码的配置来覆盖配置。

我们还使用以下代码将连接字符串移动到app.config文件。

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

<configuration> 
   
   <startup> 
      <supportedRuntime version = "v4.0" sku = ".NETFramework,Version = v4.5" /> 
   </startup> 
   
   <connectionStrings> 
      <add name = "default" connectionString = "Data Source =
         asia13797\\sqlexpress;
         Initial Catalog = NHibernateDemoDB;
         Integrated Security = True;
         Connect Timeout = 15;
         Encrypt = False;
         TrustServerCertificate = False;
         ApplicationIntent = ReadWrite;
         MultiSubnetFailover = False"/> 
   </connectionStrings> 

</configuration>