LCLFramework框架之Repository模式

Respository模式在示例中的实际目的小结一下

---

1. Repository模式是架构模式，在设计架构时，才有参考价值；
2. Repository模式主要是封装数据查询和存储逻辑；
3. Repository模式实际用途：更换、升级ORM 引擎，不影响业务逻辑；
4. Repository模式能提高测试效率，单元测试时，用Mock对象代替实际的数据库存取，可以成倍地提高测试用例运行速度。

Repository与Dal的区别

---

Repository是DDD中的概念，强调Repository是受Domain驱动的，Repository中定义的功能要体现Domain的意图和约束，而Dal更纯粹的就是提  供数据访问的功能,并不严格受限于Business层。

使用Repository，隐含着一种意图倾向，就是 Domain需要什么我才提供什么，不该提供的功能就不要提供，一切都是以Domain的需求为核心；而使用Dal，其意图倾向在于我Dal层能使用的数 据库访问操作提供给Business层，你Business要用哪个自己选。换一个Business也可以用我这个Dal，一切是以我Dal能提供什么操 作为核心。

LCLFramework框架之Repository模式设计

---

LCLFramework框架之Repository模式设计主要是参考http://apworks.codeplex.com/ 框架而来的，目前我只是扩展了LCL.Repositories.EntityFramework仓库，对于个人来使用已经足够了。

LCLFramework框架之Repository模式设计代码

---

 

public interface IRepository<TEntity> where TEntity : class, IEntity
  {
      IRepositoryContext Context { get; }
      void Create(TEntity entity);
      void Delete(TEntity entity);
      void Update(TEntity entity);
      IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> predicate);
      IEnumerable<TEntity> GetAll(PagingInfo paging = null);
      TEntity GetByKey(params object[] keyValues);
      IEnumerable<TEntity> GetPage(Expression<Func<TEntity, bool>> predicate,PagingInfo paging);
  }
public interface IRepositoryContext : IUnitOfWork, IDisposable
{
    Guid ID { get; }
    void RegisterNew(object obj);
    void RegisterModified(object obj);
    void RegisterDeleted(object obj);
} 

public interface IUnitOfWork
{
    bool DistributedTransactionSupported { get; }
    bool Committed { get; }
    void Commit();
    void Rollback();
}
/* 

职责： 

   1：定义一个“仓库”基类 

   2：与WCF交互，Repository<TEntity>类的红色部分是与WCF交互的代码。通过“数据门户”来决定是本地执行还是网络执行。 

*/ 

public abstract partial class Repository<TEntity> : IRepository<TEntity>
    where TEntity : class, IEntity
{
    /// <summary>
    /// 是否声明本仓库为本地仓库（客户端只在客户端查询，服务端在服务端查询）
    /// </summary>
public DataPortalLocation DataPortalLocation { get; protected set; } 

    private readonly IRepositoryContext context;
    public Repository(IRepositoryContext context)
    {
        this.context = context;
this.DataPortalLocation = DataPortalLocation.Dynamic;
    }
    public IRepositoryContext Context
    {
        get { return this.context; }
    }
    #region IRepositoryContext
    #region CUD
    protected abstract void DoAdd(TEntity entity);
    protected abstract void DoRemove(TEntity entity);
    protected abstract void DoUpdate(TEntity entity);
    [Obfuscation]
    public void Create(TEntity entity)
    {
   this.FetchList(entity, "DoAdd");
    }
    public void Delete(TEntity entity)
    {
this.FetchList(entity, "DoRemove");
    }
    public void Update(TEntity entity)
    {
this.FetchList(entity, "DoUpdate");
    }
    #endregion 

    #region Query
    protected abstract IEnumerable<TEntity> DoGetAll(PagingInfo paging);
    protected abstract IEnumerable<TEntity> DoGet(Expression<Func<TEntity, bool>> predicate);
    protected abstract TEntity DoGetByKey(params object[] keyValues);
    protected abstract IEnumerable<TEntity> DoGetPage(Expression<Func<TEntity, bool>> predicate, PagingInfo paging);
    public IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> predicate)
    {
var list = this.FetchList(predicate, "DoGet");
        return list;
    }
    public IEnumerable<TEntity> GetAll(PagingInfo paging=null)
    {
  var list = this.FetchList(paging, "DoGetAll");
        return list;
    }
    public TEntity GetByKey(params object[] keyValues)
    {
var list = this.FetchFirst(keyValues, "GetByKey");
        return list;
    }
    public IEnumerable<TEntity> GetPage(Expression<Func<TEntity, bool>> predicate,PagingInfo paging=null)
    {
return this.FetchList(paging, "GetPage");
    }
    #endregion
    #endregion 

       #region 获取对象接口方法 

        protected TEntityList FetchListCast<TEntityList>(object criteria, string methodName) 

            where TEntityList : class, IEnumerable<TEntity> 

        { 

            return this.FetchList(criteria, methodName) as TEntityList; 

        } 

        protected TEntity FetchFirstAs(object criteria, string methodName) 

        { 

            return this.FetchFirst(criteria,methodName) as TEntity; 

        } 

        protected IEnumerable<TEntity> FetchList(object criteria, string methodName)
        {
            // 调用 " 数据门户 "
            var list = DataPortalApi.Action(this.GetType(), methodName, criteria, this.DataPortalLocation) as IEnumerable<TEntity>;
            return list;
        } 

        protected TEntity FetchFirst(object criteria, string methodName) 

        { 

            var list = this.FetchList(criteria, methodName); 

            var last = list.DefaultIfEmpty<TEntity>() as TEntity; 

            return list.Count() > 0 ? last : null; 

        } 

        #endregion
} 

public abstract class RepositoryContext :DisposableObject,IRepositoryContext 

{ 

        #region Private Fields 

        private readonly Guid id = Guid.NewGuid(); 

        private readonly ThreadLocal<List<object>> localNewCollection = new ThreadLocal<List<object>>(() => new List<object>()); 

        private readonly ThreadLocal<List<object>> localModifiedCollection = new ThreadLocal<List<object>>(() => new List<object>()); 

        private readonly ThreadLocal<List<object>> localDeletedCollection = new ThreadLocal<List<object>>(() => new List<object>()); 

        private readonly ThreadLocal<bool> localCommitted = new ThreadLocal<bool>(() => true); 

        #endregion 

        #region Protected Properties 

        protected IEnumerable<object> NewCollection 

        { 

            get { return localNewCollection.Value; } 

        } 

        protected IEnumerable<object> ModifiedCollection 

        { 

            get { return localModifiedCollection.Value; } 

        } 

        protected IEnumerable<object> DeletedCollection 

        { 

            get { return localDeletedCollection.Value; } 

        } 

        #endregion 

        #region Protected Methods 

        protected void ClearRegistrations() 

        { 

            this.localNewCollection.Value.Clear(); 

            this.localModifiedCollection.Value.Clear(); 

            this.localDeletedCollection.Value.Clear(); 

        } 

        #endregion 

        #region IRepositoryContext Members 

        public Guid ID 

        { 

            get { return id; } 

        } 

        public virtual void RegisterNew(object obj) 

        { 

            localNewCollection.Value.Add(obj); 

            Committed = false; 

        } 

        public virtual void RegisterModified(object obj) 

        { 

            if (localDeletedCollection.Value.Contains(obj)) 

                throw new InvalidOperationException("The object cannot be registered as a modified object since it was marked as deleted."); 

            if (!localModifiedCollection.Value.Contains(obj) && !localNewCollection.Value.Contains(obj)) 

                localModifiedCollection.Value.Add(obj); 

            Committed = false; 

        } 

        public virtual void RegisterDeleted(object obj) 

        { 

            if (localNewCollection.Value.Contains(obj)) 

            { 

                if (localNewCollection.Value.Remove(obj)) 

                    return; 

            } 

            bool removedFromModified = localModifiedCollection.Value.Remove(obj); 

            bool addedToDeleted = false; 

            if (!localDeletedCollection.Value.Contains(obj)) 

            { 

                localDeletedCollection.Value.Add(obj); 

                addedToDeleted = true; 

            } 

            localCommitted.Value = !(removedFromModified || addedToDeleted); 

        } 

        #endregion 

        #region IUnitOfWork Members 

        public virtual bool DistributedTransactionSupported 

        { 

            get { return false; } 

        } 

        public virtual bool Committed 

        { 

            get { return localCommitted.Value; } 

            protected set { localCommitted.Value = value; } 

        } 

        public abstract void Commit(); 

        public abstract void Rollback(); 

        #endregion 

        protected override void Dispose(bool disposing) 

        { 

            if (disposing) 

            { 

                this.localCommitted.Dispose(); 

                this.localDeletedCollection.Dispose(); 

                this.localModifiedCollection.Dispose(); 

                this.localNewCollection.Dispose(); 

            }
        }
}

LCLFramework框架之Repository扩展

---

public class EntityFrameworkRepository<TEntity> : Repository<TEntity>
        where TEntity : class, IEntity
    {
        private readonly IEntityFrameworkRepositoryContext efContext;
        public EntityFrameworkRepository(IRepositoryContext context)
            : base(context)
        {
            if (context is IEntityFrameworkRepositoryContext)
                this.efContext = context as IEntityFrameworkRepositoryContext;
        }
        protected override void DoAdd(TEntity entity)
        {
            efContext.RegisterNew(entity);
        }
        protected override void DoRemove(TEntity entity)
        {
            efContext.RegisterDeleted(entity);
        }
        protected override void DoUpdate(TEntity entity)
        {
            efContext.RegisterModified(entity);
        }
        protected override IEnumerable<TEntity> DoGetAll(PagingInfo paging)
        {
            if (paging != null)
            {
                paging.TotalCount = efContext.Context.Set<TEntity>().Count();
                return efContext.Context.Set<TEntity>().OrderBy(t => t.ID).Skip(paging.PageNumber - 1 * paging.PageSize).Take(paging.PageSize).ToList();
            }
            else
            {
                return efContext.Context.Set<TEntity>().ToList();
            }
        }
        protected override IEnumerable<TEntity> DoGet(Expression<Func<TEntity, bool>> predicate)
        {
            return efContext.Context.Set<TEntity>().Where(predicate).ToList();
        }
        protected override TEntity DoGetByKey(params object[] keyValues)
        {
            return efContext.Context.Set<TEntity>().Find(keyValues);
        }
        protected override IEnumerable<TEntity> DoGetPage(Expression<Func<TEntity, bool>> predicate, PagingInfo paging = null)
        {
            if (paging != null)
            {
                paging.TotalCount = efContext.Context.Set<TEntity>().Count();
                return efContext.Context.Set<TEntity>().OrderBy(predicate).Skip((paging.PageNumber - 1) * paging.PageSize).Take(paging.PageSize).ToList();
            }
            else
            {
                return efContext.Context.Set<TEntity>().OrderBy(predicate).ToList();
            }
        }
    }
public interface IEntityFrameworkRepositoryContext : IRepositoryContext
{
        DbContext Context { get; }
}
public class EntityFrameworkRepositoryContext : RepositoryContext, IEntityFrameworkRepositoryContext
    {
        #region Private Fields
        private readonly DbContext efContext;
        private readonly object sync = new object();
        #endregion
        #region Ctor
        public EntityFrameworkRepositoryContext(DbContext efContext)
        {
            this.efContext = efContext;
        }
        #endregion
        #region Protected Methods
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                efContext.Dispose();
            }
            base.Dispose(disposing);
        }
        #endregion
        #region IEntityFrameworkRepositoryContext Members
        public DbContext Context
        {
            get { return this.efContext; }
        }
        #endregion
        #region IRepositoryContext Members
        public override void RegisterNew(object obj)
        {
            this.efContext.Entry(obj).State = System.Data.Entity.EntityState.Added;
            Committed = false;
        }
        public override void RegisterModified(object obj)
        {
            this.efContext.Entry(obj).State = System.Data.Entity.EntityState.Modified;
            Committed = false;
        }
        public override void RegisterDeleted(object obj)
        {
            this.efContext.Entry(obj).State = System.Data.Entity.EntityState.Deleted;
            Committed = false;
        }
        #endregion
        #region IUnitOfWork Members
        public override bool DistributedTransactionSupported
        {
            get { return true; }
        }
        public override void Commit()
        {
            if (!Committed)
            {
                lock (sync)
                {
                    efContext.SaveChanges();
                }
                Committed = true;
            }
        }
        public override void Rollback()
        {
            Committed = false;
        }
        #endregion
    }

LCLFramework框架之Repository使用

---

public class Village : DomainEntity
    {
        public string Name { get; set; }
    }
public interface IVillageRepository : IRepository<Village>
    {
        //仓库扩展
        List<Village> GetTest();
    }
    [Serializable]
    [RepositoryFor(typeof(Village))]
    public class VillageRepository : EntityFrameworkRepository<Village>, IVillageRepository
    {
        private readonly IRepositoryContext context;
        public VillageRepository(IRepositoryContext context)
            : base(context)
        {
           this.context = context;
        }
        //仓库扩展方法
        public List<Village> GetTest()
        {
            return new List<Village>();
        }
    }