LCLFramework框架之Repository模式

最新推荐文章于 2024-04-23 09:58:05 发布
最新推荐文章于 2024-04-23 09:58:05 发布
阅读量290 收藏
点赞数
本文介绍了Repository模式的实际应用价值，包括封装数据查询与存储逻辑、更换ORM引擎不影响业务逻辑、提高单元测试效率等。同时探讨了Repository与Dal的区别，并通过LCLFramework框架展示了Repository模式的设计与实现。
摘要由CSDN通过智能技术生成

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仓库，对于个人来使用已经足够了。

ard_thumb[1]

LCLFramework框架之Repository模式设计代码

clipboard[1] 

复制代码 
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扩展

clipboard[2]

复制代码 
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>(); 
        } 
    }
复制代码
kxinyu
关注
DDD之Repository模式
weixin_45596022的博客
05-02 3239
一，传统架构下的实体模型 传统的应用架构，几乎就是根据需求设计数据库的表，根据表建立实体，对应着实体的就是DAO，Service，Controller，也就是传统的MVC三层架构。 回顾下我们平时写的代码，里面有着很多的xxxUtils工具类，很多的参数校验逻辑与业务逻辑混杂在一起，很多的实体类直接与数据库进行一对一映射。 好处很明显，在业务初期，开发起来很容易，相对比较简单，流水线式编码，但是，一旦后期需求变更，业务改造，数据库表发生变化，可能给我们带来毁灭性的负担。所谓牵一发而动全身，前面欠下了技术债，
repository模式
黄腾霄的博客
05-08 1863
今天和大家介绍一下一种特殊的设计模式——仓库模式（repository pattern） 什么是仓库模式（repository pattern） Martin Flower对此的定义是领域模型层和数据映射层中间的间接层。它封装了一系列数据库对象以及对应的操作。实现了领域模型和数据访问层的解耦。 Repository 模式作用 试想一下，在你的程序中，有多处地方需要查询，修改数据。 你肯定不希望在各个地方重复书写数据访问代码，所以你会将其放置在同一处地方（数据访问层）。 这在大部分场景下都能够满足要求。
Respository
07-17
好多很有用的jar包，开发中常用的jar包，有助于急用时拿来使用
Entity Framework Repository模式
weixin_33978016的博客
10-28 135
Repository模式之前 如果我们用最原始的EF进行设计对每个实体类的“C（增加）、R（读取）、U（修改）、D（删除）”这四个操作。 第一个：先来看看查询，对于实体类简单的查询操作，每次都是这样的过程会在代码中拥有大量的重复 极为类似的代码段。 using (var db = new EFContext("EFContext")) {...
分享基于Entity Framework的Repository模式设计（附源码）
weixin_34152820的博客
09-07 234
关于Repository模式，在这篇文章中有介绍，Entity Framework返回IEnumerable还是IQueryable?  这篇文章介绍的是使用Entity Framework实现的Repositoy模式设计，欢迎各位拍砖. 阅读目录: 一、实现的思路和结构图 二、Repository设计具体的实现代码 三、Repository设计的具体的使用 四、总结 一，实...
LCLFramework框架 1.1 Pre-Alpha 源码公布
weixin_34345560的博客
11-23 97
使用开发框架的好处：1.框架在技术上为软件系统提供了完整的模式实践2.框架为团队提供了合理可行的软件开发过程模式3.框架的应用大大提高了团队的开发效率，团队只需要关注与领域相关的业务实现，而无需关注具体的技术实现4.框架的应用大大降低了出现缺陷（Bug）的几率，因为大多数支撑业务系统的代码都经过了严格的测试和实战的考验5.框架的应用还为软件系统的整合与集成带来了便捷 LCLFramework 框...
Repository模式
08-29 169
近来发现很多ASP.NET MVC的例子中都使用了Repository模式，比如Oxite，ScottGu最近发布的免费的ASP.NET MVC教程都使用了该模式。就简单看了下。在《企业架构模式》中，译者将Repository翻译为资源库。给出如下说明：通过用来访问领域对象的一个类似集合的接口，在领域与数据映射层之间进行协调。在《领域驱动设计：软件核心复杂性应对之道》中，译者将Repository
如何在Laravel5.8中正确地应用Repository设计模式
10-15
Repository设计模式是一种软件设计模式，它提供了一个更加抽象的数据访问层。在Laravel5.8中，通过应用Repository设计模式，开发者可以将业务逻辑与数据访问逻辑分离开来，从而提高代码的可维护性与可测试性。这篇...
Entity Framework Repository(含依赖注入)
05-23
Entity Framework Repository(含依赖注入)
LCLFramework：一款高效、灵活的.NET开发框架
最新发布
gitblog_00076的博客
04-23 235
LCLFramework：一款高效、灵活的.NET开发框架 去发现同类优质开源项目:https://gitcode.com/ 是一个由卢明桂开发的开源.NET框架，旨在简化Web应用和桌面应用的开发过程，提高开发效率并提供强大的扩展性。此框架基于Microsoft的ASP.NET MVC和Entity Framework，结合了众多最佳实践，为开发者带来了一种全新的编程体验。 技术分析 LCLFr...
LCLFramework架构必须要知道的知识
weixin_33916256的博客
09-02 115
技术实现： 代码是否面向对象，要看你的继承怎么用 用抽象来展现层次感 用接口来制定操作的统一性 依赖住入(Inversion of Control) Unit of Work Repository  Domain Model Service Layer Transaction Script Model View Controller Value Object Plugi...
Entity framework Repository 结构重新整理现有项目
lorinzhang
07-04 1547
还是首先说场景           上头要求必须满足的几大条件：   1--开发速度要快   2--实施方便（因为是以产品形式，必须实施方便）           3--对开发人员要求低（减少成本）           4--引用要方便，要开放平台，容易提供给第三方结构 于是得出：    1-- 开发速度快使用 EF 这个应该是目前开发速度最快的了          2--实施方便，
Repository:C＃中存储库模式的通用实现
04-27
第二个是名为EFRepository的实体框架存储库，它使用作为其存储接口。 这就是AzureRepository ，它是Repository的实现。 第四个是FileSystemRepository ，该实现将对象直接序列化到文件系统。 欢迎并鼓励提出其他...
（五）Repository（仓储层）
qq_54750179的博客
01-13 3563
学习资料记录
LCLFramework框架之Service模式
weixin_34010949的博客
11-24 112
Service模式介绍      领域中的一些概念不太适合建模为对象，即归类到实体对象或值对象，因为它们本质上就是一些操作，一些动作，而不是事物。这些操作或动作往往会涉及到多个领域对象，并且需要协调这些领域对象共同完成这个操作或动作。如果强行将这些操作职责分配给任何一个对象，则被分配的对象就是承担一些不该承担的职责，从而会导致对象的职责不明确很混乱。但是基于类的面向对象语言规定任何属性或行为都...
MVC架构中的Repository模式 个人理解
07-22 542
关于MVC架构中的Repository模式 个人理解：Repository是一个独立的层，介于领域层与数据映射层（数据访问层）之间。它的存在让领域层感觉不到数据访问层的存在，它提供一个类似集合的接口提供给领域层进行领域对象的访问。Repository是仓库管理员，领域层需要什么东西只需告诉仓库管理员，由仓库管理员把东西拿给它，并不需要知道东西实际放在哪。 tabbycat的理解（来源）： 1. Repository模式是架构模式，在设计架构时，才有参考价值； 2.Rep...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值