NHibernate从入门到精通系列(7)——多对一关联映射-优快云博客

本文介绍了NHibernate框架中多对一关联映射的概念、配置及使用方法。包括多对一映射的实现原理、异常处理技巧、查询方式等关键信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　　内容摘要

　　多对一关联映射概括

　　多对一关联映射插入和查询

　　多对一关联映配置介绍

　　一、多对一关联映射概括

　　关联关系是实体类与实体类之间的结构关系，分别为“多对一”、“一对一”、“多对多”。然而“多对一”是怎样描述的呢？让我们参考图1.1所示：

图1.1　

　　学生表“T_Student”有两条记录，它们分别对应了班级表“T_Class”的主键值为“1”的同一条记录。所以这就是“多对一”的使用情景。

　　让我们看一下“多对一”持久化类的结构：

     public class Class
    {
         public virtual int ? ID { get ; set ; }

         public virtual string Name { get ; set ; }
    }

     public class Student
    {
         public virtual int ? ID { get ; set ; }

         public virtual string Name { get ; set ; }

         public virtual Class Class { get ; set ; }
    }

　　在“Student”类中有类型为“Class”的属性，这就意味着在“Student”有一个与之对应的“Class”类。

　　再让我们看一下映射文件：

< class name ="Class" table ="T_Class" lazy ="true" >
     < id name ="ID" type ="int" column ="ClassID" >
       < generator class ="native" />
     </ id >

     < property name ="Name" type ="string" >
       < column name ="Name" length ="50" />
     </ property >

   </ class >

   < class name ="Student" table ="T_Student" lazy ="true" >
     < id name ="ID" type ="int" column ="StudentID" >
       < generator class ="native" />
     </ id >

     < property name ="Name" type ="string" >
       < column name ="Name" length ="50" />
     </ property >

     < many-to-one name ="Class" column ="ClassID" />

   </ class >

　　我在“Student”类的映射文件中发现了“many-to-one”节点，<many-to-one>标签是描述“多对一”的关联映射。

　　该标签的name属性是“多对一”的类名，column是外键字段名。

　　我们配置好映射文件后运行程序，生成的表结构如图1.2所示：

图1.2

　　发现NHibernate帮我们生成了一个外键。

　　二、多对一关联映射插入和查询

　　2.1 多对一关联映射插入

　　我们编写一个测试类，测试一下“多对一”关联映射的插入。

　　代码如下：

[TestFixture]
     public class NHibernateInit
    {
         private ISessionFactory sessionFactory;

        [SetUp]
         public void InitTest()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure( " Config/hibernate.cfg.xml " );
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
         public void Save()
        {
             using (ISession session = this .sessionFactory.OpenSession())
            {
                var cls = new Class { Name = " 1班 " };

                var liu = new Student { Name = " 刘冬 " , Class = cls };
                var zhang = new Student { Name = " 张三 " , Class = cls };

                ITransaction tran = session.BeginTransaction();
                 try
                {
                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                 catch (Exception ex)
                {
                    tran.Rollback();
                     throw ex;
                }
            }
        }
    }

　　使用NUnit运行测试类。如图2.1.1所示，发现抛出“object references an unsaved transient instance - save the transient instance before flushing. Type: Domain.Class, Entity: Domain.Class”这样的异常。

图2.1.1

　　这个异常是怎么回事呢？持久化“Student”类的实例后，“Student”类的实例变为“持久态(Persistent)”，而“Class”类的实例还是临时态(Transient)，当持久化一个持久态的实例时，若该实例引用了一个临时态的实例，就会抛出这样的异常。

　　我们修改一下代码：

[Test]
         public void Save()
        {
             using (ISession session = this .sessionFactory.OpenSession())
            {
                var cls = new Class { Name = " 1班 " };

                var liu = new Student { Name = " 刘冬 " , Class = cls };
                var zhang = new Student { Name = " 张三 " , Class = cls };

                ITransaction tran = session.BeginTransaction();
                 try
                {
                     // 持久化“Class”类
                    session.Save(cls);

                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                 catch (Exception ex)
                {
                    tran.Rollback();
                     throw ex;
                }
            }
        }

　　然后运行修改过的程序。如图2.1.2所示，运行成功。

图2.1.2

　　同理，我们也可以修改<many-to-one>标签中的cascade属性为“all”,这样就能实现同样的效果。设置cascade属性后，当持久态的实例引用临时态的实例时，NHibernate就会帮我们把这个临时态的实例自动持久化到数据库中。

　　2.2 多对一关联映射查询

　　我们编写一个查询方法，当获取到“Student”时，可以通过其“Class”属性读取“Class”的信息。

        [Test]
         public void Select()
        {
             using (ISession session = this .sessionFactory.OpenSession())
            {
                var student = session.CreateQuery( " from Student " ).List < Student > ().First();

                Console.WriteLine( " 学生名为：{0} " , student.Name);

                Console.WriteLine( " 班级名为：{0} " , student.Class.Name);
            }
        }

　　运行效果如图2.2.1所示，我们并没有再去调用查询方法，就能获取到关联的信息。

图2.2.1

　　三、多对一关联映配置介绍

　　<many-to-one
        name="PropertyName"                                属性名
        column="column_name"                               数据库字段名
        class="ClassName"                                  关联的类的名字
        cascade="all|none|save-update|delete"              级联关系
        fetch="join|select"                                抓取
        update="true|false"                                
        insert="true|false"                                
        property-ref="PropertyNameFromAssociatedClass"     指定关联类的一个属性，这个属性将会和本外键相对应
        access="field|property|nosetter|ClassName"         
        unique="true|false"                                是否生成一个唯一约束
        optimistic-lock="true|false"                       
        not-found="ignore|exception"                       指定外键引用的数据不存在时如何处理
　　/>

　　代码下载

　　出处：http://www.cnblogs.com/GoodHelper/archive/2011/02/24/nhibernate07.html

　　欢迎转载，但需保留版权。

转载于:https://www.cnblogs.com/GoodHelper/archive/2011/02/24/nhibernate07.html