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"></property>
      <property name="generate_statistics">false</property>
      <property name="format_sql">true</property>
      <property name="command_timeout"></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"></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", "");
                c.Properties.Add("generate_statistics", "false");
                c.Properties.Add("format_sql", "true");
                c.Properties.Add("command_timeout", "");
                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 = ;
             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 = ;
             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 = ;
             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 = ;
             //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() > ;
         }

         #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
     }