NHibernate开源框架Cuyahoga学习之数据访问接口的实现

代码

一．数据访问接口
using  System;
using  System.Collections;
using  System.Collections.Generic;
using  NHibernate.Criterion;
namespace  Cuyahoga.Core.DataAccess
{
     public   interface  ICommonDao
    {
        
         object  GetObjectById(Type type,  int  id);
         object  GetObjectById(Type type,  int  id,  bool  allowNull);
        T GetObjectById < T > ( int  id);
object  GetObjectByDescription(Type type,  string  propertyName,  string  description);
        IList GetAll(Type type);
        IList < T >  GetAll < T > ();
        IList GetAll(Type type,  params   string [] sortProperties);
        IList < T >  GetAll < T > ( params   string [] sortProperties);
        IList < T >  GetAllByCriteria < T > (DetachedCriteria criteria);
        IList < T >  GetByIds < T > ( int [] ids);
         void  SaveOrUpdateObject( object  obj);
       void  UpdateObject( object  obj);
       void  SaveObject( object  obj);
         void  DeleteObject( object  obj);
         void  MarkForDeletion( object  obj);
         void  RemoveCollectionFromCache( string  roleName);
         void  RemoveCollectionFromCache( string  roleName,  int  id);
         void  RemoveQueryFromCache( string  cacheRegion);
         void  Flush();
    }
}
二．数据访问接口实现
using  System;
using  System.Collections;
using  System.Collections.Generic;
using  NHibernate;
using  NHibernate.Criterion;
using  Castle.Facilities.NHibernateIntegration;
using  Castle.Services.Transaction;

namespace  Cuyahoga.Core.DataAccess
{
     ///   <summary>
     ///  Functionality for common simple data access. The class uses NHibernate.
     ///   </summary>
    [Transactional]
     public   class  CommonDao : ICommonDao
    {
         private   readonly  ISessionManager _sessionManager;

         ///   <summary>
         ///  Constructor.
         ///   </summary>
         ///   <param name="sessionManager"></param>
         public  CommonDao(ISessionManager sessionManager)
        {
             this ._sessionManager  =  sessionManager;
        }

         #region  ICommonDao Members

         public   object  GetObjectById(Type type,  int  id)
        {
            ISession session  =   this ._sessionManager.OpenSession();
             return  session.Load(type, id);
        }

         public   object  GetObjectById(Type type,  int  id,  bool  allowNull)
        {
             if  ( !  allowNull)
            {
                 return  GetObjectById(type, id);
            }
             else
            {
                ISession session  =   this ._sessionManager.OpenSession();
                 return  session.Get(type, id);
            }
        }

         public  T GetObjectById < T > ( int  id)
        {
            ISession session  =   this ._sessionManager.OpenSession();
             return  session.Get < T > (id);
        }

         public   object  GetObjectByDescription(Type type,  string  propertyName,  string  description)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            ICriteria crit  =  session.CreateCriteria(type);
            crit.Add(Expression.Eq(propertyName, description));
             return  crit.UniqueResult();
        }

         public  IList GetAll(Type type)
        {
             return  GetAll(type,  null );
        }

         public  IList GetAll(Type type,  params   string [] sortProperties)
        {
            ISession session  =   this ._sessionManager.OpenSession();

            ICriteria crit  =  session.CreateCriteria(type);
             if  (sortProperties  !=   null )
            {
                 foreach  ( string  sortProperty  in  sortProperties)
                {
                    crit.AddOrder(Order.Asc(sortProperty));
                }
            }
             return  crit.List();
        }

         ///   <summary>
         ///  Get all objects of T.
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <returns></returns>
         public  IList < T >  GetAll < T > ()
        {
             return  GetAll < T > ( null );
        }

         ///   <summary>
         ///  Get all objects of T.
         ///   </summary>
         ///   <param name="sortProperties"></param>
         ///   <typeparam name="T"></typeparam>
         ///   <returns></returns>
         public  IList < T >  GetAll < T > ( params   string [] sortProperties)
        {
            ISession session  =   this ._sessionManager.OpenSession();

            ICriteria crit  =  session.CreateCriteria( typeof (T));
             if  (sortProperties  !=   null )
            {
                 foreach  ( string  sortProperty  in  sortProperties)
                {
                    crit.AddOrder(Order.Asc(sortProperty));
                }
            }
             return  crit.List < T > ();
        }

         ///   <summary>
         ///  Get all objects of T that match the given criteria.
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="criteria"> NHibernate DetachedCriteria instance. </param>
         ///   <returns></returns>
         ///   <remarks>
         ///  Be careful to not use this one from the UI layer beacuse it ties the UI to NHibernate.
         ///   </remarks>
         public  IList < T >  GetAllByCriteria < T > (DetachedCriteria criteria)
        {
             using  (ISession session  =   this ._sessionManager.OpenSession())
            {
                ICriteria crit  =  criteria.GetExecutableCriteria(session);
                 return  crit.List < T > ();
            }
        }

         ///   <summary>
         ///  Get all objects of T for the given id's.
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="ids"></param>
         ///   <returns></returns>
         public  IList < T >  GetByIds < T > ( int [] ids)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            ICriteria crit  =  session.CreateCriteria( typeof (T))
                .Add(Expression.In( " Id " , ids));
             return  crit.List < T > ();
        }

        [Transaction(TransactionMode.Requires)]
         public   virtual   void  SaveOrUpdateObject( object  obj)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.SaveOrUpdate(obj);
        }


        [Transaction(TransactionMode.Requires)]
         public   virtual   void  SaveObject( object  obj)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.Save(obj);
        }

        [Transaction(TransactionMode.Requires)]
         public   virtual   void  UpdateObject( object  obj)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.Update(obj);
        }

        [Transaction(TransactionMode.Requires)]
         public   virtual   void  DeleteObject( object  obj)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.Delete(obj);
        }

         public   void  MarkForDeletion( object  obj)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.Delete(obj);
        }

         public   void  RemoveCollectionFromCache( string  roleName)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.SessionFactory.EvictCollection(roleName);
        }

         public   void  RemoveCollectionFromCache( string  roleName,  int  id)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.SessionFactory.EvictCollection(roleName, id);
        }

         public   void  RemoveQueryFromCache( string  cacheRegion)
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.SessionFactory.EvictQueries(cacheRegion);
        }

         public   void  Flush()
        {
            ISession session  =   this ._sessionManager.OpenSession();
            session.Flush();
        }

         #endregion
    }
}