NHiberante从.net framework转移到.net standard(.net core 2.2)时遇到的坑及填坑

在.net framework中的创建session代码先贴一个

    public class SessionBuilder
    {
        private static ISessionFactory _sessionFactory = null;

        public SessionBuilder()
        {
            if (_sessionFactory == null)
            {
                //创建ISessionFactory
                _sessionFactory = GetSessionFactory();
            }
        }

        /// <summary>
        /// 创建ISessionFactory
        /// </summary>
        /// <returns></returns>
        public static ISessionFactory GetSessionFactory()
        {
            //HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();

            var mappers = new ModelMapper();
            mappers.AddMappings(Assembly.GetExecutingAssembly().GetExportedTypes());

            var cfg = new Configuration().Configure();
            cfg.AddDeserializedMapping(mappers.CompileMappingForAllExplicitlyAddedEntities(), "");

            return cfg.BuildSessionFactory();
        }

        /// <summary>
        /// 打开ISession
        /// </summary>
        /// <returns></returns>
        public static ISession GetSession()
        {
            if (_sessionFactory == null || _sessionFactory.IsClosed)
            {
                //创建ISessionFactory
                _sessionFactory = GetSessionFactory();
            }
        }


        #region 打开一个新的Session
        public static ISession OpenSession()
        {
            return _sessionFactory.OpenSession();

        }
        #endregion

    }

与数据库的交互时，需要先在web.config配置（数据库为sql server）

<configuration>
  <configSections>
    <section name="hibernate-configuration" type="NHibernate.Cfg.ConfigurationSectionHandler, NHibernate" />
  </configSections>
  <!--NHibernate配置开始-->
  <hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
    <session-factory>
      <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
      <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
      <property name="dialect">NHibernate.Dialect.MsSql2012Dialect</property>
      <property name="show_sql">false</property>
      <property name="connection.connection_string_name">ylsdai</property>
      <property name="adonet.batch_size">30</property>
      <property name="generate_statistics">false</property>
      <property name="format_sql">true</property>
      <property name="command_timeout">60</property>
      <property name="current_session_context_class">web</property>
      <!--<property name="cache.provider_class">NHibernate.Caches.SysCache2.SysCacheProvider,NHibernate.Caches.SysCache2</property>
      <property name="cache.default_expiration">120</property>
      <property name="cache.use_second_level_cache">true</property>
      <property name="cache.use_query_cache">true</property>-->
    </session-factory>
  </hibernate-configuration>
  <!--NHibernate配置结束-->
  <connectionStrings>
    <!--test_db-->
    <!--<add name="ylsdai" connectionString="data source=0.0.0.1,111;database=test_db;uid=sa;pwd=123456" providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

映射类

using NHibernate.Mapping.ByCode;
using NHibernate.Mapping.ByCode.Conformist;

namespace ClassMapping
{
    #region CityMap
    public class CityMap : ClassMapping<City>
    {
        public CityMap()
        {
            
            SelectBeforeUpdate(true);
            DynamicUpdate(true);
            //Cache(p => p.Usage(CacheUsage.ReadWrite));
            Id(p => p.CityId, map => map.Generator(Generators.Native));
            Property(p => p.OldCityId);
            Property(p => p.ParentId);
            Property(p => p.CityName);
            Property(p => p.EnCityName);
            Property(p => p.CityImgUrl);
            Property(p => p.LatLng);
            Property(p => p.Keywords);
            Property(p => p.IsRecommend);
            Property(p => p.IsDepart);
            Property(p => p.AreaId);
            Property(p => p.CityContent);
        }
    }
    #endregion
}

将实体写好，就可以进行实现了

但是在迁移到.net core的时候遇到的问题：

1. 创建Session，使用.net framework的方法将不可用

2.config中对于NHiberante的配置也读取不到

3.基于问题1，映射类也无法进行实现

好在是在.net core中有一个辅助的开源框架Fluent NHibernate，它可以帮我解决上面遇到的问题，但是在具体使用时也踩了不少坑

1.网上的文档基本都是映射类在xml中的，但是当实际项目在.cs文件中时，大量的文件映射从.cs文件迁到到.xml文件将变得特别繁琐

最后的解决办法，创建session方法中GetSessionFactory方法做以下修改

        /// <summary>
        /// 创建ISessionFactory
        /// </summary>
        /// <returns></returns>
        public static ISessionFactory GetSessionFactory()
        {
            var assemblyName = Assembly.Load("ClassMapping");

            NHibernate.Cfg.Configuration setCfg(NHibernate.Cfg.Configuration c)
            {
                c.Properties.Add("show_sql", "true");
                c.Properties.Add("adonet.batch_size", "1000");
                c.Properties.Add("generate_statistics", "false");
                c.Properties.Add("format_sql", "true");
                c.Properties.Add("command_timeout", "60");
                c.Properties.Add("current_session_context_class", "web");
                return c;
            }

            return Fluently.Configure().Database(
FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2012.ConnectionString("Server=0.0.0.1,111;Database=test_db;Uid=sa;Pwd=123456;"))
                        .Mappings(m => m.FluentMappings.AddFromAssembly(assemblyName))
                        .ExposeConfiguration(c => new SchemaUpdate(c).Execute(true, false))
                        .ExposeConfiguration(c => setCfg(c))
                        //.ExposeConfiguration(f => f.SetInterceptor(new SqlStatementInterceptor()))
                        .BuildSessionFactory();

        }

其中映射类的引入在

.Mappings(m => m.FluentMappings.AddFromAssembly(assemblyName))

这句话，是将命名空间引入，所以具体映射类可以重新新建一个项目，名字就叫做ClassMapping，具体的映射类做以下修改

using Entity;
using FluentNHibernate.Mapping;

namespace ClassMapping
{
    #region CityMap
    public class CityMap : ClassMap<City>
    {
        public CityMap()
        {
            Table("City");

            //SelectBeforeUpdate(true);
            //DynamicUpdate(true);
            //Cache(p => p.Usage(CacheUsage.ReadWrite));
            Id(p => p.CityId);
            Map(p => p.OldCityId);
            Map(p => p.ParentId);
            Map(p => p.CityName);
            Map(p => p.EnCityName);
            Map(p => p.CityImgUrl);
            Map(p => p.LatLng);
            Map(p => p.Keywords);
            Map(p => p.IsRecommend);
            Map(p => p.IsDepart);
            Map(p => p.AreaId);
            Map(p => p.CityContent);
        }
    }
    #endregion

}

在迁移过程中会碰到映射关系的迁移

以前的版本中为

            OneToOne(p => p.City, map =>
            {
                map.Cascade(Cascade.All);
                map.Lazy(LazyRelation.Proxy);
            });//一对一

            ManyToOne(p => p.Province, map => map.Column("ProvinceId"));//多对一

            Bag(p => p.Counties, map =>
            {
                map.Key(k => k.Column("CountyId"));
                map.OrderBy(k => k.SortId);
            }, rel => rel.OneToMany());//一对多

.net core版本中对应为

HasOne(p => p.City).Cascade.All().LazyLoad();//一对一

//References<Province>(r => r.Province).Column("ProvinceId").ForeignKey("ProvinceId").Cascade.None();//多对一，在实际运用中会出现问题

HasMany(p => p.Counties).KeyColumn("CountyId").OrderBy("CountyId").LazyLoad();//一对多

city实体

    [Serializable]
    public class City : BaseEntity
    {
         /// <summary>
         /// CityId
         /// </summary>
        public virtual int CityId { get; set; }

        /// <summary>
        /// Version
        /// </summary>
        public virtual int Version { get; set; }

        /// <summary>
        /// OldCityId
        /// </summary>
        public virtual int OldCityId { get; set; } 

         /// <summary>
         /// ParentId
         /// </summary>
        public virtual int ParentId { get; set; } 

         /// <summary>
         /// 城市名称
         /// </summary>
        public virtual string CityName { get; set; } 

         /// <summary>
         /// 城市英文名称
         /// </summary>
        public virtual string EnCityName { get; set; } 

         /// <summary>
         /// CityImgUrl
         /// </summary>
        public virtual string CityImgUrl { get; set; } 

         /// <summary>
         /// 经纬度
         /// </summary>
        public virtual string LatLng { get; set; } 

         /// <summary>
         /// 关键字
         /// </summary>
        public virtual string Keywords { get; set; }

        /// <summary>
        /// 是否推荐
        /// </summary>
        public virtual bool IsRecommend { get; set; }

        /// <summary>
        /// IsDepart
        /// </summary>
        public virtual bool IsDepart { get; set; } 

         /// <summary>
         /// 航区
         /// </summary>
        public virtual int AreaId { get; set; } 

         /// <summary>
         /// 城市介绍
         /// </summary>
        public virtual string CityContent { get; set; } 

    }

下面是操作session，进行数据库调用的方法

    /// <summary>
    /// Hibernate操作Helper 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class DbHelper<T> where T : BaseEntity
    {
        private readonly ISession _session = SessionBuilder.GetSession();
        //protected static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        public DbHelper() { }

        public DbHelper(ISession session)
        {
            _session = session;
        }

        #region 获取一个实体
        /// <summary>
        /// 获取一个实体（一级缓存）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Load(int id)
        {
            return _session.Load<T>(id);
        }

        #endregion

        #region 获取一个实体（缓存）
        /// <summary>
        /// 获取一个实体（二级缓存）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get(int id)
        {
            return _session.Get<T>(id);
        }
        #endregion

        #region 销毁一个实体
        /// <summary>
        /// 销毁一个实体
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public void Evict(object obj)
        {
            _session.Evict(obj);
        }
        #endregion

        /// <summary>
        /// 根据SQL语句获取
        /// </summary>
        /// <param name="sql"></param>
        public ISQLQuery CreateSqlQuery(string sql)
        {
            return _session.CreateSQLQuery(sql);
        }

        /// <summary>
        /// 获取集合
        /// </summary>
        /// <param name="hql"></param>
        /// <returns></returns>
        public ICriteria GetCriteria(string hql)
        {
            return _session.CreateCriteria(hql);
        }

        #region 获取全部数据
        /// <summary>
        /// 获取全部数据
        /// </summary>
        /// <param name="cacheable">是否缓存</param>
        /// <returns></returns>
        public IEnumerable<T> GetAll(bool cacheable)
        {
            var ic = _session.CreateCriteria(typeof(T));
            IEnumerable<T> list = ic.SetCacheable(cacheable).List<T>() ?? new List<T>();
            return list;
        }
        #endregion

        #region 插入或者更新数据
        /// <summary>
        /// 插入数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Save(T entity)
        {
            var id = 0;
            var session = this._session;
            ITransaction tan = session.BeginTransaction();

            try
            {
                entity = session.Merge(entity);
            }
            catch (Exception e)
            {
                //Log.DebugFormat($"Save124，Exception：{e.Message}，entity:{JsonConvert.SerializeObject(entity)}");
            }

            try
            {
                tan.Begin();
                id = (int)session.Save(entity);
                session.Flush();
                tan.Commit();
            }
            catch (Exception e)
            {
                //Log.DebugFormat($"Save136，Exception：{e.Message}，entity:{JsonConvert.SerializeObject(entity)}");
                tan.Rollback();
                throw;
            }

            return id;
        }
        #endregion

        #region 更新数据
        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Update(T entity)
        {
            int result = 0;
            ITransaction tan = _session.BeginTransaction();
            var session = this._session;
            //entity = (T)_session.Merge(entity);
            try
            {
                entity = session.Merge(entity);
            }
            catch (Exception e)
            {
                //Log.DebugFormat($"Update163，Exception：{e.Message}，entity:{JsonConvert.SerializeObject(entity)}");
            }
            try
            {
                tan.Begin();
                _session.Update(entity);
                _session.Flush();
                tan.Commit();
                result++;
            }
            catch (Exception e)
            {
                //Log.DebugFormat($"Update175，Exception：{e.Message}，entity:{JsonConvert.SerializeObject(entity)}");
                tan.Rollback();
                throw;
            }
            return result;
        }
        #endregion

        #region 删除一条数据
        /// <summary>
        /// 删除一条数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int DeleteModelById(int id)
        {
            int result = 0;
            object item = Get(id);
            //ITransaction tan = _session.BeginTransaction();
            try
            {
                //tan.Begin();
                _session.Delete(item);
                _session.Flush();
                //tan.Commit();
                result++;
            }
            catch (Exception)
            {
                //tan.Rollback();
                throw;
            }

            return result;
        }
        #endregion

        #region 删除一个实体对象
        /// <summary>
        /// 删除一个实体对象
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int DeleteModel(BaseEntity entity)
        {
            var result = 0;
            //ITransaction tan = _session.BeginTransaction();
            try
            {
                //tan.Begin();
                _session.Delete(entity);
                _session.Flush();
                //tan.Commit();
                result++;
            }
            catch (Exception)
            {
                //tan.Rollback();
                throw;
            }
            return result;
        }
        #endregion

        /// <summary>
        /// 根据SQL语句删除
        /// </summary>
        /// <param name="sql"></param>
        public void DeleteList(string sql)
        {
            _session.CreateSQLQuery(sql).UniqueResult();
        }

        /// <summary>
        /// 删除泛型集合
        /// </summary>
        /// <param name="models"></param>
        public void DeleteList(IList<T> models)
        {
            foreach (var model in models)
            {
                DeleteModel(model);
            }
        }

        public bool IsExist(Expression<Func<T, bool>> keyWhere)
        {
            var ss = _session.QueryOver<T>().Where(keyWhere);
            return ss.RowCount() > 0;
        }

        #region GetQuery
        /// <summary>
        /// GetQuery
        /// </summary>
        /// <returns></returns>
        public IQueryable<T> GetQuery()
        {
            try
            {
                return _session.Query<T>();
            }
            catch (Exception e)
            {
                var session = SessionBuilder.GetSession();
                return session.Query<T>();
            }
        }
        #endregion

        #region GetQueryOver
        /// <summary>
        /// GetQueryOver
        /// </summary>
        /// <returns></returns>
        public IQueryOver<T, T> GetQueryOver(Expression<Func<T, bool>> keyWhere)
        {
            return _session.QueryOver<T>().Where(keyWhere);
        }

        #endregion

        #region GetQueryOver
        /// <summary>
        /// GetQueryOver
        /// </summary>
        /// <returns></returns>
        public IQueryOver<T, T> GetQueryOver()
        {
            return _session.QueryOver<T>();
        }
        #endregion

        #region 获取集合ByHql
        /// <summary>
        /// 获取集合ByHql
        /// </summary>
        /// <param name="strHql"></param>
        /// <returns></returns>
        public IQuery GetQueryByHql(string strHql)
        {
            return _session.CreateQuery(strHql);
        }
        #endregion

        #region 获取集合BySql
        /// <summary>
        /// 获取集合BySql
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public IQuery GetQueryBySql(string strSql)
        {
            return _session.CreateSQLQuery(strSql);
        }
        #endregion
    }