您所在的位置：程序员俱乐部 > 编程开发 > .NET > 分享基于Entity Framework的Repository模式设计（附源码）

分享基于Entity Framework的Repository模式设计（附源码）

2013/9/7 23:11:37 JustRun 博客园我要评论(0)

摘要：关于Repository模式，在这篇文章中有介绍，EntityFramework返回IEnumerable还是IQueryable?这篇文章介绍的是使用EntityFramework实现的Repositoy模式设计，欢迎各位拍砖.阅读目录:一、实现的思路和结构图二、Repository设计具体的实现代码三、Repository设计的具体的使用四、总结一，实现的思路和结构图总结一下，Repository在实际使用中，有下面三种特点:Repository的共同性有一些公共的方法(增删改查)
标签：Framework 源码模式设计

关于Repository模式，在这篇文章中有介绍，Entity Framework返回IEnumerable还是IQueryable?

这篇文章介绍的是使用Entity Framework实现的Repositoy模式设计，欢迎各位拍砖.

阅读目录:

一、实现的思路和结构图

二、Repository设计具体的实现代码

三、Repository设计的具体的使用

四、总结

一，实现的思路和结构图

总结一下，Repository在实际使用中，有下面三种特点:

Repository的共同性

有一些公共的方法(增删改查)，这些方法无关于Repository操作的是哪个实体类，可以把这些方法定义成接口IRepository<TEntity>, 然后有个基类BaseRepository<TEntity>实现该接口的方法。

常见的方法，比如Find, Filter, Delete, Create等

Repository的差异性

每个Repository类又会有一些差异性，应当允许它们能够继承BaseRepository<TEntity>之外，还能够再扩展自己的一些方法。所以每个类都可以再定义一个自己特有的接口，定义一些属于自己Repository的方法。

Repository的协同性

不同的Repository可能需要协同，Repository对数据的修改，需要在统一的保存.

最终实现的类结构图如下:

二，Repository设计具体的实现代码

IRepository<TEntity>接口定义了Repository共有的方法, BaseRepository<TEntity>实现了这些接口的方法。其它的Repository类再集成BaseRepository<TEntity>方法，就天然的得到了对数据操作的基本方法。

IRepository<TEntity>代码

public interface IRepository<TEntity> where TEntity : class
{
      IQueryable<TEntity> All();
      IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate);
      IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0, int size = 50);
      bool Contains(Expression<Func<TEntity, bool>> predicate);
      TEntity Find(params object[] keys);
      TEntity Find(Expression<Func<TEntity, bool>> predicate);
      TEntity Create(TEntity t);
      int Delete(TEntity t);
      int Delete(Expression<Func<TEntity, bool>> predicate);
      int Update(TEntity t);
      TEntity Single(Expression<Func<TEntity, bool>> expression);
}

BaseRepository<TEntity>代码

logs_code_hide('049bcf6e-2ae6-4864-b548-8e7bd6d11a51',event)" src="/Upload/Images/2013090723/2B1B950FA3DF188F.gif" alt="" />

public class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
       protected readonly DbContext Context;

       public BaseRepository(DbContext context)
       {
           Context = context;
       }

       public TEntity Single(Expression<Func<TEntity, bool>> expression)
       {
           return All().FirstOrDefault(expression);
       }

       public IQueryable<TEntity> All()
       {
           return Context.Set<TEntity>().AsQueryable();
       }

       public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate)
       {
           return Context.Set<TEntity>().Where<TEntity>(predicate).AsQueryable<TEntity>();
       }

       public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0,
                                              int size = 50)
       {
           var skipCount = index * size;
           var resetSet = filter != null
                               ? Context.Set<TEntity>().Where<TEntity>(filter).AsQueryable()
                               : Context.Set<TEntity>().AsQueryable();
           resetSet = skipCount == 0 ? resetSet.Take(size) : resetSet.Skip(skipCount).Take(size);
           total = resetSet.Count();
           return resetSet.AsQueryable();
       }

       public virtual TEntity Create(TEntity TObject)
       {
           var newEntry = Context.Set<TEntity>().Add(TObject);
           Context.SaveChanges();
           return newEntry;
       }

       public virtual int Delete(TEntity TObject)
       {
           Context.Set<TEntity>().Remove(TObject);
           return Context.SaveChanges();
       }

       public virtual int Update(TEntity TObject)
       {
           try
           {
               var entry = Context.Entry(TObject);
               Context.Set<TEntity>().Attach(TObject);
               entry.State = EntityState.Modified;
               return Context.SaveChanges();
           }
           catch (OptimisticConcurrencyException ex)
           {
               throw ex;
           }
       }

       public virtual int Delete(Expression<Func<TEntity, bool>> predicate)
       {
           var objects = Filter(predicate);
           foreach (var obj in objects)
               Context.Set<TEntity>().Remove(obj);
           return Context.SaveChanges();
       }

       public bool Contains(Expression<Func<TEntity, bool>> predicate)
       {
           return Context.Set<TEntity>().Count<TEntity>(predicate) > 0;
       }

       public virtual TEntity Find(params object[] keys)
       {
           return Context.Set<TEntity>().Find(keys);
       }

       public virtual TEntity Find(Expression<Func<TEntity, bool>> predicate)
       {
           return Context.Set<TEntity>().FirstOrDefault<TEntity>(predicate);
       }
}

View Code

IUnitOfWorkRepository接口定义了方法获取特定的Repository, 执行存储过程, SaveChange方法提交修改，统一更新数据。

IUnitOfWorkRepository接口代码:

public interface IUnitOfWorkRepository : IDisposable
{
      TRepository GetRepository<TRepository>() where TRepository : class;
      void ExecuteProcedure(string procedureCommand, params object[] sqlParams);
      void SaveChanges();
}

UnitOfWorkRepository代码, 代码中使用到了Autofac中的IComponentContext来获取Repository实例

public class UnitOfWorkRepository : IUnitOfWorkRepository
{
       private readonly IComponentContext _componentContext;
       protected readonly DbContext Context;

       public UnitOfWorkRepository(DbContext context, IComponentContext componentContext)
       {
           Context = context;
           _componentContext = componentContext;
       }

       public TRepository GetRepository<TRepository>() where TRepository : class
       {
           return _componentContext.Resolve<TRepository>();
       }

       public void ExecuteProcedure(string procedureCommand, params object[] sqlParams)
       {
           Context.Database.ExecuteSqlCommand(procedureCommand, sqlParams);
       }

       public void SaveChanges()
       {
           Context.SaveChanges();
       }

       public void Dispose()
       {
           if (Context != null)
               Context.Dispose();
       }
}

三, Repository设计的具体的使用

这里我们定义一个操作Student的Repository类，看看如何实际用于开发中。这里加入StudentRepository有自己特定的方法，需要获取所有的Students，这个扩展的方法名字叫GetAllStudents

那么定义一个接口IStudentRepository, 包含了方法GetAllStudents(), 同时继承IRepository<Student>接口

public interface IStudentRepository : IRepository<Student>
{
      IEnumerable<dynamic> GetAllStudents();
}

然后定义StudentRepository类来实现这个接口

public class StudentRepository : BaseRepository<Student>, IStudentRepository
{
       private readonly SchoolContext _context;

       public StudentRepository(SchoolContext context)
           : base(context)
       {
           _context = context;
       }

       public IEnumerable<dynamic> GetAllStudents()
       {
           return _context.Students;
       }
}

使用Repository的代码如下:

IUnitOfWorkRepository unitOfWorkRepository = new UnitOfWorkRepository();

var studentRepository = unitOfWorkRepository.GetRepository<IStudentRepository>();
var students = studentRepository.GetAllStudents();

//同时你也可以使用定义于IRepository<Student>中的方法， 比如
//unitOfWorkRepository.Delete(students.First());
//unitOfWorkRepository.SaveChanges();