DB First 中对Repository 层封装的几点小记

在数据库表创建完成的情况下，使用DB First 进行开发，封装底层会遇到一些小问题，在此记录一下，供以后参考。

主要解决的问题有：

1、EF上下文管理

2、BaseRepository的封装

3、EF中实体序列化的问题

1、EF上下文管理

          EF操作数据库的上下文，要达到在用户每一次的请求操作中都只有一个上下文，当用户通过Http请求结束后要释放用户使用的上下文资源，也就

是EF生成中的ObjectContext不能每次使用时候通过new 创建一个新的实例，一次请求只需要创建一次，请求结束ObjectContext资源释放。

          这里要用到的就是单例模式和简单工厂了，单例保证只有一个ObjectContext ，每次调用通过工厂方式获取。这里直接贴代码

   public class DbContextFactory
    {
       private static string efKey = "ef_key";

       public static RBACEntities GetContext() 
       {
           RBACEntities db = CallContext.GetData(efKey) as RBACEntities;
           if (db == null) 
           {
               db = new RBACEntities();
               CallContext.SetData(efKey,db);
           }
           Debug.WriteLine("EF上下文获取：" + db.GetHashCode() + ",时间：" + DateTime.Now.ToString("hh-mm-ss ffff"));
           return db;
       }

       public static void Dispose() 
       {
           var context=GetContext();
           Debug.WriteLine("EF上下文释放：" + context.GetHashCode() + ",时间：" + DateTime.Now.ToString("hh-mm-ss ffff"));
           context.Dispose();
       }
    }

 然后，在Global.asax中，在请求结束事件中调用释放资源方法。

       protected void Application_EndRequest()
        {
            Dedeyi.RBAC2.Core.Model.DbContextFactory.Dispose();
        }

　　　　 Debug.WriteLine是调试时候，追踪一下上下文的获取和释放是否达到目的。打开调试的Output ，检测到一次请求的输出信息

          

　　  可以看到，在这次请求处理中使用了两次上下文实例，都是同一个实例(HashCode相同)，最后又一次的资源释放。

2、BaseRepository的封装

        基仓储的封装。要实现基本的增删查改操作。在这里因为使用的是Entity Framework 中的ObjectContext进行数据库交互，其灵活性是很强的

如果只是像ADO.NET中通过sql对CRUD的封装那样，就很多地方没法发挥ObjectContex的作用了。

        所有我们在基类中要把这个上下文留出来，作为一个可以访问的属性。通过这个上下文，可以在自类中访问数据模型中其他表，ObjectSet 是对应当前EF实体对象，也把这个暴露给外面使用。然后就是分页和搜索的封装了。具体代码如下：

 public class BaseRepository<TEntity> where TEntity: EntityObject
    {
       protected RBACEntities RBACContext { get; set; }
       protected ObjectSet<TEntity> DbSet { get; set; }

       protected virtual IQueryable<TEntity> Entities 
       {
           get { return RBACContext.CreateObjectSet<TEntity>(); }
       }

       public BaseRepository() 
       {
           this.RBACContext = DbContextFactory.GetContext();
           this.DbSet=RBACContext.CreateObjectSet<TEntity>();
       }

       public IQueryable<TEntity> GetPage<TKey>(int pageIndex, int pageSize,Expression<Func<TEntity,TKey>> orderBy, out int totalRecord) 
       {
           totalRecord = DbSet.Count();
           return  this.DbSet
                      .OrderByDescending(orderBy)
                      .Skip((pageIndex - 1) * pageSize)
                      .Take(pageSize)
                      .AsQueryable();
       }

       public IQueryable<TEntity> GetPage<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderBy, Expression<Func<TEntity, bool>> where, out int totalRecord)
       {
           var res=DbSet.Where(where);

           totalRecord = res.Count();
           return  res
                      .OrderByDescending(orderBy)
                      .Skip((pageIndex - 1) * pageSize)
                      .Take(pageSize)
                      .AsQueryable();
       }


       public TEntity Add(TEntity entity,bool saveChange) 
       {
           RBACContext.CreateObjectSet<TEntity>().AddObject(entity);
           if (saveChange) 
           {
               RBACContext.SaveChanges();
           }
           return entity;
       }

       public TEntity Edit(TEntity entity, bool saveChange) 
       {
           RBACContext.CreateObjectSet<TEntity>().Attach(entity);
           RBACContext.ObjectStateManager.ChangeObjectState(entity,System.Data.EntityState.Modified);
           if (saveChange) 
           {
               RBACContext.SaveChanges();
           }
           return entity;
       }

       public void Delete(TEntity entity, bool saveChange) 
       {
           RBACContext.CreateObjectSet<TEntity>().DeleteObject(entity);
           if (saveChange) { RBACContext.SaveChanges(); }
       }
    }

      SaveChange是一个bool 类型参数，表明是否要上下文保存到数据库，如果只是修改一张表，直接保存，如果涉及多个操作，最后统一SaveChange也就实现了事务统一。

3、EF中实体序列化去除 EntityKey字段

      如果直接把EF模型数据表对应的模型进行序列化，会得到很多跟EF相关的属性，要去掉这些多余的属性，就响应对序列化进行一些修改了。

这里使用的是Newtonsoft.Net进行序列化的。具体封装源码：

    public class JsonNet
    {
        /// <summary>
        /// 将实体对象转换成Json字符串 
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public static string SerializeToString(object item)
        {
           return JsonConvert.SerializeObject(item, Formatting.Indented,
                new JsonSerializerSettings
                {
                    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                    ContractResolver = new ExcludePropertiesContractResolver(new List<string> { "EntityKey" }),
                });

        }

        /// <summary>
        /// 将Json字符串转换成实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        public static T DeserializeToEntity<T>(string jsonString)
        {
            return JsonConvert.DeserializeObject<T>(jsonString);
        }
    }

    public class ExcludePropertiesContractResolver : DefaultContractResolver
    {
        IEnumerable<string> lstExclude;

        public ExcludePropertiesContractResolver(IEnumerable<string> excludedProperties)
        {
            lstExclude = excludedProperties;
        }

        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            return base.CreateProperties(type, memberSerialization).ToList().FindAll(p => !lstExclude.Contains(p.PropertyName));
        }
    }