Fluent NHibernate关系映射

1.好处：Fluent NHibernate让你不再需要去写NHibernate的标准映射文件(.hbm.xml), 方便了我们的代码重构，提供了代码的易读性，并精简了项目代码

实现：

(1)、首先我们通过nuget包管理器添加FluentNHibernate与NHibernate的引用。

(2)、编写实体类，注意实体的属性都是virtual

(3)、实体类编写完成以后我们用代码的方式实现对实体的映射

Fluent NHibernate主要实现的映射关系：一对一、一对多、多对一、多对多

下面介绍几种映射关系中主讲一对多关联属性

2. 一对一映射 HasOne<>()

2.1. 定义支持的关联属性

Cascade 指该对象在进行操作时关联到的子对象的操作类型

PropertyRef属性一般用来解决遗留数据库一对多关系的问题

PropertyRef被关联到此外键的类中的对应属性的名字,若没指定,使用被关联类的主键.

PropertyRef不是数据库表中的字段名,而是定义的类中的属性名

Fetch    在外连接抓取或者序列选择抓取选择其一.

class：被关联的类的名字

constrained  表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。 这个选项影响Save()和Delete()在级联执行时的先后顺序以及决定该关联能否被委托

2.1.1.映射范例

用户和用户信息表在实际中是一对一的关系，这两个表之间是通过使用UserID来相互关联的，UserDetail使用的主键ID与User的ID是一致的，所以我们要使用Foregin来获取User的ID，它们有一个共同的ID，在插入Users表的同时也要写入UserDetail表，所以需要添加一对一的限制关系，具体的在User和UsersDetai两表的映射方法如下代码

　　public　UserMap()　

{　

Table("Users");

　　　　Id(u　=>　u.UserID).GeneratedBy.Identity()　;　

　　　　Map(u　=>　u.UserName);　

　　　　Map(u　=>　u.Password);　

　　　　Map(u　=>　u.CreateTime);　

　　　　HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().PropertyRef("User");　

}　

　　public　UserDetailMap()　

{　

Table("UserDetais");

　　　　Id(u　=>　u.UserID).Column("UserID").GeneratedBy.Foreign("User");　

　　　　HasOne<User>(d　=>　d.User).Cascade.All().Constrained();　

　　　　Map(u　=>　u.LastUpdated).Nullable();　

　　　　Component<PersonName>(u　=>　u.Name,　p　=>　

　　　　{　

　　　　　　p.Map(o　=>　o.FirstName).Column("[First　Name]");　

　　　　　　p.Map(o　=>　o.LastName).Column("[Last　Name]");　

　　　　});　

}　

2.1.2.补充说明

上面指定了All说明所有的操作都会关联到子表，还有SaveUpdate在添加和更新时关联子表，另外还有None类型不推荐使用此类型因为会出现很多问题。

一对一延迟加载

有时对我们来说，只需要User就可以了，我不需要查询UserDetail，或许你会说，使用以下方式来进行延迟加载：

HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().LazyLoad();

虽然Fluent支持，虽然编译通过，但在创建ISessionFactory的时候，却会抛出异常，因为NHibernate不支持HasOne的不支持一对一的延迟Lazy加载的特性, 可以用:

HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().Fetch.Select();

HasOne<User>(d　=>　d.User).Cascade.All().Constrained();

3. 一对多HasMany<>() / 多对一 References<>()

3.1. 定义支持的关联属性

KeyColumn  表示主键名

Cascade表示级联取值，决定是否把对对象的改动反映到数据库中，所以Cascade对所有的关联关系都起作用, Cascade是操作上的连锁反映，Cascade取值可能是以下：

AllDeleteOrphan       在关联对象失去宿主(解除父子关系)时,自动删除不属于父对象的子对象, 也支持级联删除和级联保存更新.

DeleteOrphan           删除所有和当前对象解除关联关系的对象

All                 级联删除, 级联更新,但解除父子关系时不会自动删除子对象.

Delete                                  级联删除, 但不具备级联保存和更新

None                                     所有操作均不进行级联操作

SaveUpdate                        级联保存(load以后如果子对象发生了更新,也会级联更新). 在执行save/update/saveOrUpdate时进行关联操作,它不会级联删除

Inverse()    所描述的是对象之间关联关系的维护方式，作用是：是否将对集合对象的修改反映到数据库中。Inverse表示对集合对象的修改会被反映到数据库中；

为了维持两个实体类（表）的关系，而添加的一些属性，该属性可能在两个实体类（表）或者在一个独立的表里面，这个要看这双方直接的对应关系了： 这里的维护指的是当主控方进行增删改查操作时，会同时对关联关系进行对应的更新，Inverse是操作上的连锁反映。

ForeignKeyConstraintName   外键约束名

Access   NHibernate用来访问属性的策略。

unique: 为外键字段生成一个唯一约束。此外， 这也可以用作PropertyRef的目标属性。这使关联同时具有 一对一的效果。

OptimisticLock  定这个属性在做更新时是否需要获得乐观锁定（OptimisticLock）。 换句话说，它决定这个属性发生脏数据时版本（version）的值是否增长。

NotFound   指定外键引用的数据不存在时如何处理： ignore会将数据不存在作为关联到一个空对象（null）处理。

IsProxy     指定一个类或者接口，在延迟装载时作为代理使用。

Schema

3.1.1. 映射范例

一个用户可以拥有多个订单，一个订单只能拥有一个用户，对于用户来说，不需要每次都加载订单列表，反之订单可能每次都需要加载用户信息。

　　public　UserMap()　

{　

Table("Users");

　　　　Id(u　=>　u.UserID).GeneratedBy.Identity()　;　

　　　　Map(u　=>　u.UserName);　

　　　　Map(u　=>　u.Password);　

　　　　Map(u　=>　u.CreateTime);　

　　　　HasOne<UserDetail>(u　=>　u.Detail).Cascade.All().Fetch.Select();　//一对一映射用户和用户信息表

　　　　HasMany<Order>(u　=>　u.Orders).AsSet().KeyColumn("UserID").Cascade.All();　////处理一对多关系的映射，一个User可以有多个订单, 关联的数据表进行懒加载，主键名为UserID,级联关系所有操作

}

　　public　OrderMap()　

　　{　

Table("Orders");

　　　　Id(o　=>　o.OrderID).GeneratedBy.Identity();　

　　　　Map(o　=>　o.Price);　

　　　　Map(o　=>　o.State).CustomType<OrderState>();　

　　　　Map(o　=>　o.Address);　

　　　　Map(o　=>　o.Coignee);　

　　　　Map(o　=>　o.CreateTime);　

　　　　Map(o　=>　o.Zip);　

　　　　References<User>(o　=>　o.User).Not.LazyLoad().Column("UserID");　 //处理多对一关系，多个Order可以属于一个User

　　}　

/// <summary>

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

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

/// </summary>

public CustomerMapping()

{

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

Table("TB_Customer");

//自动增长的id

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

//映射关系

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

//指定主键后一定要加上主键字段的映射关系，不然返回的id为new Guid(),也就是一串0

Map(m => m.CustomerID).Nullable();

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

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

Map(m => m.Version);

//处理一对多关系的映射，一个客户可以有多个订单

//关联的数据表进行懒加载，主键名为CustomerID,级联关系所有操作，cascade：All|delete|saveorUpdate,级联删除时需加上Inverse()

//     Inverse the ownership of this entity. Make the other side of the relationship

//     responsible for saving.

HasMany<Order>(h => h.Orders).LazyLoad().AsSet().KeyColumn("CustomerID").Cascade.All().Inverse();

}

首先是Tasks表的映射，因为Tasks表是多的一端，所以要添加对Projects表的外键引用关系，另外因为是一种外键引用不关系到父表的操作，所以这里可以使用Cascade.None()。

public TasksMappping()

{

Table("Tasks");

LazyLoad();

Id(x => x.ID).Column("TaskID").GeneratedBy.Identity();

References(x => x.Project).Nullable().Column("ProjectID").Cascade.None();//处理多对一关系，多个Tasks可以属于一个Project

Map(x => x.Name).Nullable();

}

在Projects表中，因为该表中的一个ID会对应多个Tasks所以在添加HasMany方法，来表明Projects和Tasks的多对一的关系，如下代码它会涉及到任务的添加和更新操作，所以需要使用Cascade.SaveUpdate()。

public ProjectsMapping()

{

Table("Projects");

LazyLoad();

Id(x => x.ID).Column("ProjectID").GeneratedBy.Identity();

References(x => x.User).Column("UserID").Cascade.None(); //它的操作不会涉及到Projects的操作

Map(x => x.Name).Nullable();

HasMany(x => x.Task).KeyColumn("ProjectID").LazyLoad().Cascade.SaveUpdate();

//在save或者update Projects的时候会连带着修改Tasks

}

3.1.2.补充说明

一对多的映射，比起一对一来说还相对的简单点，默认是延迟加载，如果项目中，有些地方，需要立即加载，我们也可以使用 FetchMode.Eager 来加载;

4. 多对多映射 HasManyToMany <>()

4.1. 定义支持的关联属性

ParentKeyColumn        定义与A表关联的字段名

ChildKeyColumn         定义与B表关联的字段名

Table                  关系表

4.1.1. 映射范例

比如电子商务站的订单和产品的关系

　　public　ProductMap()　

　　{　

Table("Products");

　　　　Id(p　=>　p.ProductID);　

　　　　HasManyToMany<Order>(p　=>　p.Orders)　

　　　　　　.AsSet()　

　　　　　　.LazyLoad()　

　　　　　　.ParentKeyColumn("ProductID")　

　　　　　　.ChildKeyColumn("OrderID")　

　　　　　　.Table("OrderProduct");　

　

　　　　Map(p　=>　p.CreateTime);　

　　　　Map(p　=>　p.Name);　

　　　　Map(p　=>　p.Price);　

　　}　

　　public　OrderMap()　

　　{　

Table("Orders");

　　　　Id(o　=>　o.OrderID).GeneratedBy.Identity();　

　　　　HasManyToMany<Product>(o　=>　o.Products)　

　　　　　　.AsSet()　

　　　　　　.Not.LazyLoad()　

　　　　　　.Cascade.All()　

　　　　　　.ParentKeyColumn("OrderID")　

　　　　　　.ChildKeyColumn("ProductID")　

　　　　　　.Table("OrderProduct");　

　

　　　　Map(o　=>　o.Price);　

　　　　Map(o　=>　o.State).CustomType<OrderState>();　

　　　　Map(o　=>　o.Address);　

　　　　Map(o　=>　o.Coignee);　

　　　　Map(o　=>　o.CreateTime);　

　　　　Map(o　=>　o.Zip);　

　　　　References<User>(o　=>　o.User).Not.LazyLoad().Column("UserID");　//多个订单属于一个客户

　　}　

这里我们用了一个单独的一个表OrderProduct来保存这个多对多关系

比如 一个Project会有有很多Product，同时一个Product也可能会在多个Project中

public ProjectsMapping()

{

Table("Projects");

LazyLoad();

Id(x => x.ID).Column("ProjectID").GeneratedBy.Identity();

References(x => x.User).Column("UserID").Cascade.None();

Map(x => x.Name).Nullable();

HasMany(x => x.Task).KeyColumn("ProjectID").LazyLoad().Cascade.SaveUpdate();

HasManyToMany(x => x.Product).ParentKeyColumn("ProjectID").ChildKeyColumn("ProductID").Table("ProjectProduct");

}

public ProductMapping()

{

Table("Product");

Id(x => x.ID).Column("ProductID").GeneratedBy.Identity();

Map(x => x.Name).Nullable();

Map(x => x.Color).Nullable();

HasManyToMany(x => x.Project).ParentKeyColumn("ProductID").ChildKeyColumn("ProjectID").Table("ProjectProduct");

}

4.1.2.补充说明

具体添加关联的步骤如下：

（1）在映射的两端同时添加HasManyToMany的关系这样就形成了双向的关联关系

（2）指定映射的ParentKey和ChildKey，一般会将对象本身的ID指定为ParentKey，关联对象的ID指定为ChildKey

（3）指定关联关系的关系表，使用Table方法指定关联表，如上示例的Table("ProjectProduct")。

以上只为突出一对一的双向关联映射，一对多的单向关联和多对多的双向关联关系