NHibernate 状态的概念 以及 小测试

在 NHibernate中有三种状态。

• 临时态（Transient）：用new创建的对象，它没有持久化，没有纳入Session中，随时可以被垃圾回收，处于此状态的对象叫临时对象。特点：数据库中没有与之对应的记录；
• 持久态（Persistent）：已经持久化，加入到了Session缓存中。通过NHibernate保存的对象或通过Get/Load等方法获取出的对象，其对象没有脱离Session的管理，处于此状态的对象叫持久对象；
• 游离态（Detached）：持久化对象脱离了Session的对象。如Session缓存被清空的对象。特点：已经持久化，但不在Session缓存中。处于此状态的对象叫游离对象；

 临时态(Transient)到持久态(Persistent)

先new一个对象，该对象的状态为Transient，然后调用Save()方法将该对象持久化到数据库中，该对象的状态变为Persistent。在未关闭Session前，修改该对象的属性，最后提交事务。

  /// <summary>
        /// 临时态-->持久态
        /// </summary>
        [Test]
        public void TransientToPersistentTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    //Transient
                    var product = new Product
                    {
                        ID = Guid.NewGuid(),
                        BuyPrice = 10M,
                        Code = "ABC123",
                        Name = "电脑",
                        QuantityPerUnit = "20x1",
                        SellPrice = 11M,
                        Unit = "台"
                        
                    };  

                    try
                    {
                        //Persistent
                        session.Save(product);

                        //保存记录后修改数据，观察数据库中数据的变化
                        product.SellPrice = 12M;

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

这时，我们心里便产生了一个疑问：把Product的SellPrice属性从“11M”修改为“12M”后，并没有调用Save()或者Update()的方法，为什么数据库中的数据会变呢？

　　这是因为，当对象处于Persistent状态，并没有脱离Session管理时，其属性发生改变后，数据库相对应的记录会与之同步。

持久态(Persistent)到游离态(Detached)，再到持久态(Persistent)

 /// <summary>
        /// 持久态-->游离态-->持久态
        /// </summary>
        [Test]
        public void PersistentToTestDetached()
        {
            //Transient
            var product = new Product
            {
                ID = Guid.NewGuid(),
                BuyPrice = 10M,
                Code = "ABC123",
                Name = "电脑",
                QuantityPerUnit = "20x1",
                SellPrice = 11M,
                Unit = "台"
            };

            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {                
                    try
                    {
                        //Persistent
                        session.Save(product);
                        product.SellPrice = 12M;

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

            //Detached
            product.SellPrice = 13M;

            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        //Persistent
                        session.Update(product);
                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }

当对象处于游离态(Detached)时，修改其属性，是不会与数据库发生同步的。调用Update()方法后，对象则变回持久态(Persistent)。

Get方法得到持久态(Persistent)

        [Test]
        public void PersistentToTestDetached()
        {
            //Transient
            string  ID1 = Guid.NewGuid().ToString();
            var product = new Product
            {
                ID = ID1,
                BuyPrice = 10M,
                Code = "ABC123",
                Name = "电脑",
                QuantityPerUnit = "20x1",
                SellPrice = 11M,
                Unit = "台"
            };

            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        //Persistent
                        session.Save(product);
                        product.SellPrice = 12M;

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

            //Detached
           

            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        //Persistent
                        product=session.Get<Product>(ID1);//Get可与Load互换
                        product.SellPrice = 18M;
                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }

其中ID1为数据库中已存在的一条数据的主键值。在得到持久化对象后，我们便可以更改数据库的值。

 Get和Load()方法的区别

Load：

• Load方法可以对查询进行优化。
• Load方法实际得到一proxy对象，并不立即查询数据库。当访问对象的属性的时候才查询数据库。在NHibernate里称为Lazy Loding（延迟加载）。
• Load方法得到的对象，如果对象不存在，在访问对象的属性时将抛出异常。
• 当需要得到实体对象，但是不需要访问对象属性的时候，宜使用Load方法。比如Delete方法：

   调用Load()方法查询数据库中不存在的对象，返回值不为空；当调用Load()方法时，不立刻产生SQL语句，查看其属性后才产生SQL语句，并且查看数据库中不存在对象的属性时会抛出异常。原因是调用Load()方法会返回一个“代理类”，这是NHibernate的一个重要的特性——延迟加载。

　延迟加载(lazy load)也叫“懒加载”，是NHibernate关联关系对象默认的加载方式，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。可以简单理解为，只有在使用的时候，才会发出SQL语句进行查询。 延迟加载的有效期是在Session打开的情况下，当Session关闭后，会报异常。NHibernate的代理对象是由第三方组件“Antlr3.Runtime”提供的。

Get：

• Get方法立即查询数据库，如果对象不存在，返回null。
• 调用Get()方法后，数据库中不存在的对象返回值为null，并且一但调用Get()方法，就会生成SQL语句。

Update()方法

先手动打造new一个数据库中存在的游离态（Detached）对象，然后直接调用Update()方法将对象的状态设置为持久态（Persistent）。

   [Test]
        public void UpdateTest()
        {
            Guid id = Guid.NewGuid();

            using (ISession session = this.sessionFactory.OpenSession())
            {             
                using (ITransaction tran = session.BeginTransaction())
                {
                    //Transient
                    var product = new Product
                    {
                        ID = id,
                        BuyPrice = 10M,
                        Code = "ABC123",
                        Name = "电脑",
                        QuantityPerUnit = "20x1",
                        SellPrice = 11M,
                        Unit = "台"

                    };

                    try
                    {
                        //Persistent
                        session.Save(product);
                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }

            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    //Detached
                    var product = new Product
                    {
                        ID = id,
                        Code = "ABC456",
                    };

                    try
                    {
                        //Persistent
                        session.Update(product);

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

有的朋友就会问，为什么new的时候也能得到游离态（Detached）对象？因为判断是否为游离态（Detached）对象，是根据数据库中是否存在与之对应的记录定夺的。

 Delete()方法

先得到一个持久态（Persistent）对象，然后调用Delete()方法删除该对象，这时该对象变回临时态（Transient）

 [Test]
        public void DeleteTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    //Transient
                    var product = new Product
                    {
                        ID = Guid.NewGuid(),
                        BuyPrice = 10M,
                        Code = "ABC123",
                        Name = "电脑",
                        QuantityPerUnit = "20x1",
                        SellPrice = 11M,
                        Unit = "台"

                    };

                    try
                    {
                        //Persistent
                        session.Save(product);

                        //Transient
                        session.Delete(product);

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

学习于      http://www.cnblogs.com/GoodHelper/archive/2011/02/17/nhibernate_04.html