MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

首页 > 代码库 > MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

2024-08-22 22:58:18 221人阅读

项目最基础的东西已经结束了，但是现在我们的项目还不健全不利于测试重复性代码多层与层之间耦合性高不利于扩展等问题.今天的这章主要就是解决这些问题的。再解决这些问题时，自己也产生了很多疑问，理解的也并不是很透彻，希望我的疑问能在这里得到解答~~

一.模式介绍

1.Repository

在《企业架构模式》中，通过用来访问领域对象的一个类似集合的接口，在领域与数据映射层之间进行协调。还有请大家参考这个 P OF EAA详细介绍

然后说下我对这个的感觉和疑问怎么都觉得这个Repository就是以前的dao(dal)层~~ 不过就是通过接口泛型与ORM结合实现了更好的复用不知道对不~~

2.Unit of Work

先上介绍 Unit Of Work 定义和解释。主要是解决当有多个操作时,数据的变更存储以及事务的处理等。unit of work是一个记录所有对象模型修改过的信息，在提交的时候，一次性修改，并把结果同步到数据库。其实我们可以发现 DbContext 已经具备了这样的功能~~ 很大程度实现了Unit of work~ 因为我们savechange()

时才提交数据的

3.整体概述

运用Repository 和Unit of Work 在数据层和业务逻辑层之间再创建一个抽象层。它将帮我们隔离变化，并且更利于测试.

下面借用下原文的图说明下使用Repository 和Unit of Work和不使用的区别

技术分享

二.改造开始

让我们回到最早的学生控制器上忘了讲啥的朋友可以看下这节-------学生控制器我们把

private SchoolContext db = new SchoolContext();

写在了每个控制器里面声明周期与控制器完全耦合在了一起

1.创建学生资源库接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
    public interface IStudentRepository : IDisposable
    {
        IEnumerable<Student> GetStudents();
        Student GetStudentByID(int studentId);
        void InsertStudent(Student student);
        void DeleteStudent(int studentID);
        void UpdateStudent(Student student);
        void Save();
    }
}

2.实现接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
    public class StudentRepository : IStudentRepository, IDisposable
    {
        private SchoolContext context;

        public StudentRepository(SchoolContext context)
        {
            this.context = context;
        }

        public IEnumerable<Student> GetStudents()
        {
            return context.Students.ToList();
        }

        public Student GetStudentByID(int id)
        {
            return context.Students.Find(id);
        }

        public void InsertStudent(Student student)
        {
            context.Students.Add(student);
        }

        public void DeleteStudent(int studentID)
        {
            Student student = context.Students.Find(studentID);
            context.Students.Remove(student);
        }

        public void UpdateStudent(Student student)
        {
            context.Entry(student).State = EntityState.Modified;
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
}

3.改造学生控制器

View Code

通过上面的操作现在我们的控制器针对的是一个接口而不再是直接通过dbContext 当然如果我们这里使用IOC容器将能实现更好的解耦大家可以看下

桀骜的灵魂的这篇文章

4.改造后出现的问题

1.我们本来在控制器里实现的dbContext, 现在这个被放在了Repository里因为项目会有多个Repository 所以会有多个dbContext！这是个时候当我们有

一个复杂的逻辑要用到多个Repository时比如我随便说个例子~~ 比如添加个订单更新个详细订单再删除个客户假设这一系列的逻辑是在一起的这里就会用到三个 Repository 我们要调用不同的Repository 里的 SAVE() 这时我们就要做多次提交而且不再是统一的事务了效率完整性都大大的下降了。反而失去了

dbContext 自带 Unit of Work的好处~~ 没关系后面我们会再实现Unit of Work 来改造这个问题

2.第二个问题也是个很严重的问题我们以前的时候再查找学生搜索排序以及分页时是这样的

var students = from s in context.Students
               select s;
if (!String.IsNullOrEmpty(searchString))
{
    students = students.Where(s => s.LastName.ToUpper().Contains(searchString.ToUpper())
                           || s.FirstMidName.ToUpper().Contains(searchString.ToUpper()));
}

而现在变成了

var students = from s in studentRepository.GetStudents()
               select s;

这有个很严重的问题以前是 IQueryable 而现在的是 IEnumerable 变成了数据直接全部查找出来所以再这里我觉得Repository的查找应该是返回IQueryable

而不是 IEnumerable

要不然 就出现了我最早在文中的疑问这不就是普通的CRUD 一个普通的数据访问层而已

而Repository用法我觉得应该是 返回IQueryable 参数的接受应该是一个表达式树不知道大家是否认同？希望大家帮我解决下疑惑谢谢~

再下面的公共泛型 Repository 会体现这个

三.创建一个公共的Repository

看看我们上面的学生Repository 如果我们再写课程院系等等这些代码会非常类似所以我们利用泛型注入来实现复用这里应该实现一个泛型接口和泛型类

但是原文没有实现接口~ 只有个类

让我来看下这个类

namespace ContosoUniversity.DAL
{
    public class GenericRepository<TEntity> where TEntity : class
    {
        internal SchoolContext context;
        internal DbSet<TEntity> dbSet;

        public GenericRepository(SchoolContext context)
        {
            this.context = context;
            this.dbSet = context.Set<TEntity>();
        }

        public virtual IEnumerable<TEntity> Get(
            Expression<Func<TEntity, bool>> filter = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
            string includeProperties = "")
        {
            IQueryable<TEntity> query = dbSet;

            if (filter != null)
            {
                query = query.Where(filter);
            }

            foreach (var includeProperty in includeProperties.Split
                (new char[] { ‘,‘ }, StringSplitOptions.RemoveEmptyEntries))
            {
                query = query.Include(includeProperty);
            }

            if (orderBy != null)
            {
                return orderBy(query).ToList();
            }
            else
            {
                return query.ToList();
            }
        }

        public virtual TEntity GetByID(object id)
        {
            return dbSet.Find(id);
        }

        public virtual void Insert(TEntity entity)
        {
            dbSet.Add(entity);
        }

        public virtual void Delete(object id)
        {
            TEntity entityToDelete = dbSet.Find(id);
            Delete(entityToDelete);
        }

        public virtual void Delete(TEntity entityToDelete)
        {
            if (context.Entry(entityToDelete).State == EntityState.Detached)
            {
                dbSet.Attach(entityToDelete);
            }
            dbSet.Remove(entityToDelete);
        }

        public virtual void Update(TEntity entityToUpdate)
        {
            dbSet.Attach(entityToUpdate);
            context.Entry(entityToUpdate).State = EntityState.Modified;
        }
    }
}

这里重点讲这个方法

public virtual IEnumerable<TEntity> Get(
            Expression<Func<TEntity, bool>> filter = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
            string includeProperties = "")
        {
            IQueryable<TEntity> query = dbSet;

            if (filter != null)
            {
                query = query.Where(filter);
            }

            foreach (var includeProperty in includeProperties.Split
                (new char[] { ‘,‘ }, StringSplitOptions.RemoveEmptyEntries))
            {
                query = query.Include(includeProperty);
            }

            if (orderBy != null)
            {
                return orderBy(query).ToList();
            }
            else
            {
                return query.ToList();
            }
        }

还是如上面所说我觉得这里应该返回的是 IQueryable 所以我觉得应该去掉最后的 .ToList 并且返回IQueryable

然后来看这个方法第一个接受一个表达式树其实就是过滤条件第二个是个委托主要是用来排序的第三个接受要贪婪加载哪些导航属性可以用逗号隔开

并且这里利用了下4.0的功能可以给参数个默认值都是空怎么用这个方法后面会写的有~~

还有个说的地方以前我没有提到过这里稍带的说下

     public virtual void Delete(TEntity entityToDelete)
        {
            if (context.Entry(entityToDelete).State == EntityState.Detached)
            {
                dbSet.Attach(entityToDelete);
            }
            dbSet.Remove(entityToDelete);
        }

这个 dbSet.Attach(entityToDelete); 表示将对象添加到数据库上下文中受dbcontext管理这里我有个小疑问不加这个判断是否也可以加这个的好处是？

四.创建 Unit of Work Class

创建这个类的主要目的就是为了确保多个Repository可以共享一个 database context 让我们看下这个类

namespace ContosoUniversity.DAL
{
    public class UnitOfWork : IDisposable
    {
        private SchoolContext context = new SchoolContext();
        private GenericRepository<Department> departmentRepository;
        private GenericRepository<Course> courseRepository;

        public GenericRepository<Department> DepartmentRepository
        {
            get
            {

                if (this.departmentRepository == null)
                {
                    this.departmentRepository = new GenericRepository<Department>(context);
                }
                return departmentRepository;
            }
        }

        public GenericRepository<Course> CourseRepository
        {
            get
            {

                if (this.courseRepository == null)
                {
                    this.courseRepository = new GenericRepository<Course>(context);
                }
                return courseRepository;
            }
        }

        public void Save()
        {
            context.SaveChanges();
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    context.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
}

把想让unit of work 帮你整体控制的类写到里面这里我们只写了两个

private SchoolContext context = new SchoolContext();
private GenericRepository<Department> departmentRepository;
private GenericRepository<Course> courseRepository;

实现只读属性

public GenericRepository<Department> DepartmentRepository
{
    get
    {

        if (this.departmentRepository == null)
        {
            this.departmentRepository = new GenericRepository<Department>(context);
        }
        return departmentRepository;
    }
}

最后是保存和资源的释放

好现在看下怎么用这个~

五.改变课程控制器

原文控制器代码

原文的这个demo 并没有很好的体现出使用 unit of work 的好处因为他的这个例子没有出现一个逻辑用到多个资源库的希望大家明白这点~~ 等以后的文章

我会写个完整的demo 来说明这点这里大家先看下明白怎么回事就行~

六.EF+MVC框架的疑问

1.是否有必要实现 IUnitOfWork 接口？代码大概这样

public interface IUnitOfWork

{

void Save();

IStudentRepository StudentRepository { get; }

}

实现接口

public class UnitOfWork : IUnitOfWork

{

private SchoolEntities context = new SchoolEntities();

private IStudentRepository studentRepository;

public IStudentRepository StudentRepository

{

get

{

if (this.studentRepository == null)

{

this.studentRepository = new StudentRepository(context);

}

return studentRepository;

}

}

public void Save()

{

context.SaveChanges();

}

}

控制器

private IUnitOfWork unitOfWork;

public StudentController () : this (new UnitOfWork())

{

}

public StudentController (IUnitOfWork unitOfWork)

{

this.unitOfWork = unitOfWork;

}

2. 是否有必要再加上一个服务层 service 这个层在控制器和dal 之间也就是通过 unitofwork 调用的东西等都写在servie上这样控制器里的代码会变得非常少，个人觉得应该加上service层的,但是是否需要加Iservice 接口加这个接口能获得哪些好处？我一直觉得只用给数据访问层实现接口就行 ~~

3. 这里我们是用的unit of work 完成了事务的一致性以前我是使用

using (TransactionScope transaction = new TransactionScope()){
   ....
 
   transaction.Complete(); 
  }

用这个来实现事务一致性不知道大家觉得这个和 unit of work 比怎么样？我暂时还没研究这个~ 但是小城岁月对这个做了很好的介绍感谢小城~ 大家可以参考他的这篇文章

4. 我们的缓存比如用的 mongodb 这个写到哪层比较好呢？

六.总结

经过重构代码终于有些项目的样子了~~ 下节讲讲EF的其他一些功能如直接执行SQL语句,关闭跟踪状态这些~~

MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

MVC3+EF4.1学习系列(八)-----利用Repository and Unit of Work重构项目

看完仍有疑问？有类似问题直接问程序猿