登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›NHibernate中一对一关联的延迟加载

NHibernate中一对一关联的延迟加载

豹筒生 2025-5-29 20:19:39
由于项目需要，我最近对.NET平台下各ORM框架（LINQ to SQL、Entity Framework V2 & V4、以及NHibernate）进行了功能对比，NHiberante可以说是各框架之中历史最为悠久，功能最强，也是使用最为复杂的一个。在使用NHibernate的过程中也遇到了许多麻烦，不过也得到了不少体会。例如NH的不足之处，我理想中的ORM框架是怎么样的，等等这些，以后有机会也可以慢慢和各位进行讨论。
不过这篇文章谈论的其实只是一个小技巧，一个workaround，而且甚至于这个是由于我对NHibernate不够了解而造成的。因此，如果您有更好的做法也请不吝指出。这个问题也就是“如何实现NHibernate中一对一映射的延迟加载”。
问题描述

之前对于问题的描述，其实还有很多额外的要求没有讲清楚，而需要“workaround”的现状，也是这些要求共同形成的。经过尝试，如果放弃其中任何一个（如把主表ID的生成策略从identity改为native），则可能就会有更直接的做法了。这些条件是：


  • 一对一映射
  • 主键关联
  • 主表的ID为自增字段
  • 所有字段NOT NULL。
  • 主表和子表设置级联删除
现在的问题，就是在这些条件下，如何实现“获取主表对象时，并不加载其对应的子表数据”，也就是所谓的“延迟加载”。当然，除了能够“延迟加载”以外，还必须可以插入，更新和删除——我也尝试过使用某些特殊的映射方式，可以实现延迟加载，但是却无法插入，这自然也无法满足要求。
为了便于理解和实验，我在这里也将其“具体化”。首先是Model，User和UserDetail，它们是典型的一对一关系：
  1. public class User
  2. {
  3.     public virtual int UserID { get; set; }
  4.     public virtual string Name { get; set; }
  5.     public virtual UserDetail Detail { get; set; }
  6. }
  8. public class UserDetail
  9. {
  10.     public virtual int UserID { get; set; }
  11.     public virtual int Age { get; set; }
  12.     public virtual User User { get; set; }
  13. }
复制代码
而数据库方面则是一个User表和一个UserDetail表：
  1. CREATE TABLE [dbo].[User](
  2.     [UserID] [int] IDENTITY(1,1) NOT NULL,
  3.     [Name] [nvarchar](50) NOT NULL,
  4. CONSTRAINT [PK_User] PRIMARY KEY CLUSTERED
  5. (
  6.     [UserID] ASC
  7. ))
  8. GO
  10. CREATE TABLE [dbo].[UserDetail](
  11.     [UserID] [int] NOT NULL,
  12.     [Age] [int] NOT NULL,
  13. CONSTRAINT [PK_UserDetail] PRIMARY KEY CLUSTERED
  14. (
  15.     [UserID] ASC
  16. ))
  17. GO
  19. ALTER TABLE [dbo].[UserDetail]  WITH CHECK ADD
  20. CONSTRAINT [FK_UserDetail_User] FOREIGN KEY([UserID])
  21. REFERENCES [dbo].[User] ([UserID])
  22. ON DELETE CASCADE
  23. GO
  24. ALTER TABLE [dbo].[UserDetail] CHECK CONSTRAINT [FK_UserDetail_User]
  25. GO
复制代码
User表为主表，主键为UserID，自增。UserDetail为副表，主键为UserID，同时作为外键与User表产生关联。同时，外键上设置了级联删除，也就是在删除User表的纪录时，会自动删除UserDetail的纪录。
对于环境的描述就到这里，如果您想要自己实验的话，可以直接使用这些代码。值得强调一下的是，有些朋友可能会使用NHibernate自动生成数据表，那么请注意严格调整NHibernate的配置，使其与这个环境完全相同。
传统一对一映射

关于一对一映射是否可以延迟加载的问题，我在互联网上找了许多资料。有NHibernate的资料，也有没N的资料。有的资料上说不支持，有的资料却又说可以实现。不过根据那些说“可以”的资料进行配置，却还是无法做到延迟加载。而把这个问题发到NHibernate的用户邮件列表中也没有得到答复。不管怎么样，我把普通的配置也发布在这里吧。
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHTest" namespace="NHTest">
  3.   <class name="User" table="`User`">
  4.     <id name="UserID" type="Int32" column="UserID">
  5.       <generator class="identity" />
  6.     </id>
  7.     <one-to-one name="Detail" class="UserDetail" cascade="save-update" lazy="proxy" />
  8.     <property name="Name" type="String" />
  9.   </class>
  11.   <class name="UserDetail" table="`UserDetail`" lazy="true">
  12.     <id name="UserID" type="Int32" column="UserID">
  13.       <generator class="foreign">
  14.         <param name="property">User</param>
  15.       </generator>
  16.     </id>
  17.     <one-to-one name="User" class="User" constrained="true" />
  18.     <property name="Age" type="Int32" />
  19.   </class>
  20. </hibernate-mapping>
复制代码
按照某些资料的说法，我们把one-to-one的lazy设为proxy，并且把UserDetail节点的lazy设为true，便可以实现延迟加载。也就是说，在执行以下代码时，并不会去获取UserDetail的内容：
  1. var user = session.Get<User>(1);
复制代码
可是现在，NHibernate告诉我们现在使用的SQL是这样子的（您也可以使用SQL Profiler进行观察）：
  1. SELECT
  2.     user0_.UserID as UserID0_1_,
  3.     user0_.Name as Name0_1_,
  4.     userdetail1_.UserID as UserID1_0_,
  5.     userdetail1_.Age as Age1_0_
  6. FROM
  7.     [User] user0_
  8. left outer join
  9.     [UserDetail] userdetail1_
  10.         on user0_.UserID=userdetail1_.UserID
  11. WHERE
  12.     user0_.UserID=@p0;
  13. @p0 = 1
复制代码
很明显，它仍然把UserDetail一并获取出来了。如果您觉得这里哪里错了，请告诉我。
开始绕弯路

从现在开始，我们就要走“弯路”了。虽然我们无法在一对一映射的情况下实现延迟加载，但是我们可以轻易做到“一对多”映射时，延迟加载“集合”中的子对象。我们这个workaround的关键，便是利用了“一对多”情况下的延迟加载，把“一对一”作为“一对多”的特殊情况进行处理。不过这里就需要我们修改User的Model了：
  1. public class User
  2. {
  3.     public virtual int UserID { get; set; }
  4.     public virtual string Name { get; set; }
  6.     private ISet<UserDetail> m_detailLazyProxySet;
  7.     private ISet<UserDetail> DetailLazyProxySet
  8.     {
  9.         get
  10.         {
  11.             if (this.m_detailLazyProxySet == null)
  12.             {
  13.                 this.m_detailLazyProxySet = new HashedSet<UserDetail>();
  14.             }
  16.             return this.m_detailLazyProxySet;
  17.         }
  18.         set
  19.         {
  20.             this.m_detailLazyProxySet = value;
  21.         }
  22.     }
  24.     public virtual UserDetail Detail
  25.     {
  26.         get
  27.         {
  28.             return this.DetailLazyProxySet.Count <= 0 ? null :
  29.                 this.DetailLazyProxySet.Single();
  30.         }
  31.         set
  32.         {
  33.             this.DetailLazyProxySet.Clear();
  34.             this.DetailLazyProxySet.Add(value);
  35.         }
  36.     }
  37. }
复制代码
值得一提的是，由于DetailLazyProxySet是私有的，我们必须手动地构造一个Lambda表达式传递给HasMany方法。在实际使用过程中，我们应该提供额外的辅助方法（自然是为ClassMap新增一个扩展方法），并配合约定（属性名 + LazyProxySet）来进行强类型的编码定义。它可能是这样的：
  1. public class UserMap : ClassMap<User>
  2. {
  3.     public UserMap()
  4.     {
  5.         Id(u => u.UserID).GeneratedBy.Identity();
  6.         Map(u => u.Name);
  8.         var paramExpr = Expression.Parameter(typeof(User));
  9.         var propertyExpr = Expression.Property(paramExpr, "DetailLazyProxySet");
  10.         var castExpr = Expression.Convert(propertyExpr, typeof(IEnumerable<UserDetail>));
  11.         var lambdaExpr = Expression.Lambda<Func<User, IEnumerable<UserDetail>>>(castExpr, paramExpr);
  12.         HasMany(lambdaExpr)
  13.             .LazyLoad()
  14.             .AsSet()
  15.             .KeyColumnNames.Add("UserID")
  16.             .Cascade.All()
  17.             .Inverse();
  18.     }
  19. }
  21. public class UserDetailMap : ClassMap<UserDetail>
  22. {
  23.     public UserDetailMap()
  24.     {
  25.         Id(d => d.UserID).GeneratedBy.Foreign("User");
  26.         Map(d => d.Age);
  27.         HasOne(d => d.User).Constrained();
  28.     }
  29. }
复制代码
嗯，就是这么点代码。
实验

打开NHibernate的SQL输出，并编写如下代码：
  1. var user = session.Get<User>(1);Console.WriteLine("Name: {0}", user.Name);Console.WriteLine("Age: {0}", user.Detail.Age);
复制代码
输出如下：
  1. var user = session.Get<User>(1);
  2. Console.WriteLine("Name: {0}", user.Name);
  3. Console.WriteLine("Age: {0}", user.Detail.Age);
复制代码
请注意两条输出（已标红）的位置，很明显现在已经实现了延迟加载。那么我们要“饥渴加载（Eager Load）”又当如何？其实也很简单：
  1. NHibernate:
  2.     SELECT
  3.         user0_.UserID as UserID1_0_,
  4.         user0_.Name as Name1_0_
  5.     FROM
  6.         [User] user0_
  7.     WHERE
  8.         user0_.UserID=@p0;
  9.     @p0 = 1
  10. <font color="#ff0000">===> Name: Jeffrey Zhao</font>
  11. NHibernate:
  12.     SELECT
  13.         detaillazy0_.UserID as UserID1_,
  14.         detaillazy0_.UserID as UserID0_0_,
  15.         detaillazy0_.Age as Age0_0_
  16.     FROM
  17.         [UserDetail] detaillazy0_
  18.     WHERE
  19.         detaillazy0_.UserID=@p0;
  20.     @p0 = 1
  21. <font color="#ff0000">===> Age: 25</font>
复制代码
同样，“扩展方法”配合“约定”，我们可以把SetFetchMode这行古怪的代码改成：
  1. var user = session
  2.     .CreateCriteria<User>()
  3.     .SetFetchMode("DetailLazyProxySet", FetchMode.Eager)
  4.     .Add(Expression.IdEq(8))
  5.     .UniqueResult<User>();
  6. Console.WriteLine("===> Name: {0}", user.Name);
  7. Console.WriteLine("===> Age: {0}", user.Detail.Age);
复制代码
输出如下：
  1. .SetFetchMode(u => u.Detail)...
复制代码
我们的饥渴换来数据库的级联，和谐而统一。
总结

至此，我们成功地实现了“一对一”的延迟加载，但是对NHibernate来说，一切都是个一对多的关系。我们获得了表面的成功，付出了“Model被污染”的代价。
如果您有什么更合适的方法，请告诉我。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
豹筒生
2025-5-29 20:19:39

0

粉丝关注

15

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫