MVC Repository 模式

最新推荐文章于 2021-02-16 07:59:16 发布
最新推荐文章于 2021-02-16 07:59:16 发布
阅读量113 收藏
点赞数
文章标签： 测试 数据库
原文链接：http://www.cnblogs.com/zhangyuefen/p/5078293.html
版权 
public interface IRepository<TEntity> where TEntity : class
    {

        IQueryable<TEntity> Get(
            Expression<Func<TEntity, bool>> filter = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
            string includeProperties = "");

        /// <summary>
        /// 获取一个实体对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        TEntity GetByID(object id);

        /// <summary>
        /// 添加一个实体对象
        /// </summary>
        /// <param name="entity"></param>
        void Insert(TEntity entity);

        /// <summary>
        /// 根据编号删除一个实体对象
        /// </summary>
        /// <param name="id"></param>
        void Delete(object id);

        /// <summary>
        /// 直接删除一个实体对象
        /// </summary>
        /// <param name="entityToDelete"></param>
        void Delete(TEntity entityToDelete);

        /// <summary>
        /// 更新一个实体对象
        /// </summary>
        /// <param name="entityToUpdate"></param>
        void Update(TEntity entityToUpdate);

        /// <summary>
        /// 使用原始sql获取对象
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        IQueryable<TEntity> GetWithRawSql(string query, params object[] parameters);

        /// <summary>
        /// 获取对象的可查询表格
        /// </summary>
        IQueryable<TEntity> Table { get; }

        /// <summary>
        /// 使用原始sql删除对象
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        void DeleteRawSql(string query, params object[] parameters);

        /// <summary>
        /// 使用原始sql更新对象对象
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        void UpdateRawSql(string query, params object[] parameters);


        /// <summary>
        /// 延迟添加,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayAdd(TEntity entity);


        /// <summary>
        /// 延迟修改,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayUpdate(TEntity entity);

        /// <summary>
        /// 延迟删除,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayDelete(TEntity entity);

        /// <summary>
        /// 把延迟操作全部提交
        /// </summary>
        void DelaySubmit();

        /// <summary>
        /// 执行proc_daily存储过程
        /// </summary>
        /// <returns></returns>
        int ProcDaily(ObjectParameter para);

        /// <summary>
        /// 执行proc_update_closingrate_maturityDate存储过程
        /// </summary>
        /// <returns></returns>
        int ProcUpdateClosingrateMaturityDate();

        /// <summary>
        /// 调用存储过程,SQLProcedureResult 返回各种结果
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        SQLProcedureHelp.SQLProcedureResult ExeProcedure(string procName, params object[] parameters);
    }
IRepository 
public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        internal OptionTradeDBEntities _context;
        internal DbSet<TEntity> _dbSet;

        public Repository()
        {
            this._context = new OptionTradeDBEntities();
            this._dbSet = this._context.Set<TEntity>();
        }



        public Repository(OptionTradeDBEntities context)
        {
            this._context = context;
            this._dbSet = _context.Set<TEntity>();
        }



        public virtual IQueryable<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);
            }
            else
            {
                return query;
            }
        }

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

        public virtual void Insert(TEntity entity)
        {
            _dbSet.Add(entity);
            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                        eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                            ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }
        }

        public virtual void Delete(object id)
        {
            TEntity entityToDelete = _dbSet.Find(id);
            if (entityToDelete != null)
                Delete(entityToDelete);
        }

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

        public virtual void Update(TEntity entityToUpdate)
        {
            //_dbSet.Attach(entityToUpdate);
            _context.Entry(entityToUpdate).State = EntityState.Modified;

            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                        eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                            ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }

        }

        public virtual IQueryable<TEntity> GetWithRawSql(string query, params object[] parameters)
        {
            return _dbSet.SqlQuery(query, parameters).ToList().AsQueryable();
        }

        public virtual IQueryable<TEntity> Table
        {
            get
            {
                return this._dbSet;
            }
        }


        public void DeleteRawSql(string query, params object[] parameters)
        {
            _context.Database.ExecuteSqlCommand(query, parameters);
        }


        public void UpdateRawSql(string query, params object[] parameters)
        {
            _context.Database.ExecuteSqlCommand(query, parameters);
        }


        public void DelayAdd(TEntity entity)
        {
            _dbSet.Add(entity);
        }

        public void DelayUpdate(TEntity entity)
        {
            _context.Entry(entity).State = EntityState.Modified;
        }

        public void DelayDelete(TEntity entity)
        {
            if (_context.Entry(entity).State == EntityState.Detached)
            {
                _dbSet.Attach(entity);
            }
            _dbSet.Remove(entity);
        }

        public void DelaySubmit()
        {
            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                        eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                            ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }
        }




        public int ProcDaily(ObjectParameter para)
        {
            return _context.proc_daily(para);
        }


        public int ProcUpdateClosingrateMaturityDate()
        {
            return _context.proc_update_closingrate_maturityDate();

        }


        public SQLProcedureHelp.SQLProcedureResult ExeProcedure(string procName, params object[] parameters)
        {
            SqlConnection sqlConn = (SqlConnection)_context.Database.Connection;

            try
            {
                SQLProcedureHelp.SQLProcedure sqlProcedure = new SQLProcedureHelp.SQLProcedure(sqlConn);
                SQLProcedureHelp.SQLProcedureResult result = sqlProcedure.Call(procName, parameters);
                return result;
            }
            catch
            {
                throw;
            }
            finally
            {
                sqlConn.Close();
            }
        }
    }
Repository 
public interface IService<TEntity> where TEntity : class
    {
        IEnumerable<TEntity> Get(
            Expression<Func<TEntity, bool>> filter = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
            string includeProperties = "");

        /// <summary>
        /// 获取一个实体对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        TEntity GetByID(object id);

        /// <summary>
        /// 添加一个实体对象
        /// </summary>
        /// <param name="entity"></param>
        void Insert(TEntity entity);

        /// <summary>
        /// 根据编号删除一个实体对象
        /// </summary>
        /// <param name="id"></param>
        void Delete(object id);

        /// <summary>
        /// 直接删除一个实体对象
        /// </summary>
        /// <param name="entityToDelete"></param>
        void Delete(TEntity entityToDelete);

        /// <summary>
        /// 更新一个实体对象
        /// </summary>
        /// <param name="entityToUpdate"></param>
        void Update(TEntity entityToUpdate);

        /// <summary>
        /// 使用原始sql获取对象
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        IEnumerable<TEntity> GetWithRawSql(string query, params object[] parameters);

        /// <summary>
        /// 获取对象的可查询表格
        /// </summary>
        IQueryable<TEntity> Table();


        /// <summary>
        /// 使用原始sql删除对象
        /// </summary>
        /// <param name="query"></param>
        /// <param name="parameters"></param>
        void DeleteRawSql(string query, params object[] parameters);

        /// <summary>
        /// 延迟添加,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayAdd(TEntity entity);

        /// <summary>
        /// 延迟更新,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayUpdate(TEntity entity);

        /// <summary>
        /// 延迟删除,不提交
        /// </summary>
        /// <param name="entity"></param>
        void DelayDelete(TEntity entity);

        /// <summary>
        /// 把延迟操作全部提交
        /// </summary>
        void DelaySubmit();

        /// <summary>
        /// 执行proc_daily存储过程
        /// </summary>
        /// <returns></returns>
        int ProcDaily(ObjectParameter para);

        /// <summary>
        /// 执行proc_update_closingrate_maturityDate存储过程
        /// </summary>
        /// <returns></returns>
        int ProcUpdateClosingrateMaturityDate();

        /// <summary>
        /// 调用存储过程,SQLProcedureResult 返回各种结果
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        SQLProcedureHelp.SQLProcedureResult ExeProcedure(string procName, params object[] parameters);
    }
IService 
public class Service<TEntity> : IService<TEntity> where TEntity : class
    {


        IRepository<TEntity> Repo = null;

        public Service()
        {
            this.Repo = new Repository<TEntity>();
        }

        public IEnumerable<TEntity> Get(
             Expression<Func<TEntity, bool>> filter = null,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
             string includeProperties = "")
        {
            return Repo.Get(filter, orderBy, includeProperties);
        }

        public TEntity GetByID(object id)
        {
            return Repo.GetByID(id);
        }

        public void Insert(TEntity entity)
        {
            Repo.Insert(entity);
        }

        public void Delete(object id)
        {
            Repo.Delete(id);
        }

        public void Delete(TEntity entityToDelete)
        {
            Repo.Delete(entityToDelete);
        }

        public void Update(TEntity entityToUpdate)
        {
            Repo.Update(entityToUpdate);
        }

        public IEnumerable<TEntity> GetWithRawSql(string query, params object[] parameters)
        {
            return Repo.GetWithRawSql(query, parameters);
        }

        public IQueryable<TEntity> Table()
        {
            return Repo.Table;
        }


        public void DeleteRawSql(string query, params object[] parameters)
        {
            Repo.DeleteRawSql(query, parameters);
        }


        public void DelayAdd(TEntity entity)
        {
            Repo.DelayAdd(entity);
        }

        public void DelayUpdate(TEntity entity)
        {
            Repo.DelayUpdate(entity);
        }

        public void DelayDelete(TEntity entity)
        {
            Repo.DelayDelete(entity);
        }

        public void DelaySubmit()
        {
            Repo.DelaySubmit();
        }


        public int ProcDaily(ObjectParameter para)
        {
            return Repo.ProcDaily(para);
        }


        public int ProcUpdateClosingrateMaturityDate()
        {
            return Repo.ProcUpdateClosingrateMaturityDate();
        }


        public SQLProcedureHelp.SQLProcedureResult ExeProcedure(string procName, params object[] parameters)
        {
            return Repo.ExeProcedure(procName, parameters);
        }
    }
Service

 

转载于:https://www.cnblogs.com/zhangyuefen/p/5078293.html

weixin_30679823
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MVC模式
weixin_43900761的博客
09-21 223
MVC 1、结构图 2、传值方法，对象 3、举例
MVC 模式
weixin_43250197的博客
12-06 612
MVC 模式 MVC 模式代表 Model-View-Controller（模型-视图-控制器） 模式。这种模式用于应用程序的分层开发。 Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。 View（视图） - 视图代表模型包含的数据的可视化。 Controller（控制器） - 控制器作用于模型和视图上。它控制数据流向模型对象，并...
MVC中的Repository模式
weixin_33755847的博客
09-01 324
1.首先创建一个空的MVC3应用程序，命名为MyRepository.Web，解决方案命名为MyRepository。2.添加一个类库项目，命名为MyRepository.DAL,添加一个文件夹命名为Repository来存放业务逻辑。3.继续添加一个类库项目，命名为MyRepository.Domain，添加两个文件夹Models和Infrastructure。Models来存放实体，Infra...
MVC中使用Repository模式vs2013
02-01
一、在MVC中开发的时候，避免在Controllers中直接访问数据,为了构建更加适应未来变化以及更加易于测试的MVC应用程序，应使用Repository模式。当你使用Repository模式时，你会创建一个独立的repository类，它包含了所有的数据访问逻辑。当你创建repository类时，创建了一个接口，该接口代表着所有由repository类所使用的方法。在你的控制器中，你针对接口编写代码，而不是针对repository。通过这种方式，你以后可以使用不同的数据访问技术来实现repository 二、数据访问使用EntityFramework,为了方便使用Northwind作为示例数据 三、在Models中,创建IEmployeeRepository接口 四、在Models中,创建EmployeeRepository类,该类实现IEmployeeRepository接口,并实现接口中的方法
关于MVC架构中的Repository模式
DoChengAoHan的博客
10-21 745
关于MVC架构中的Repository模式 个人理解：Repository模式是一个单独的分层，他介于service层和dao层之间，他是采用接口的方式来访问dao层的，并且Repository模式会让servic层在访问dao层时，dao层是不知道的，Repository充当了一个仓库管理员，service层（领域）只需要告诉Repository自己需要什么就可以了，Repository会把东...
Repository模式
weixin_34004750的博客
09-22 542
最近开发的MVC项目使用了Repository模式。 啥是Repository模式？ 从图看，有一个仓库接口，一个实现了这个仓库接口的基类；然后在使用方，一方面，要声明一个继承于仓库接口的子接口，另一方面，编写一个数据库操作类，继承仓库基类，并实现这个子接口。 继承仓库基类容易理解，为啥还要搞一个子接口呢？直接实现仓库接口不就完啦？思考其中原因，应该是为了控制反转，依...
基于MVC设计模式的在线图书馆管理系统.zip
最新发布
01-08
**在线图书馆管理系统基于MVC设计模式的实现** MVC（Model-View-Controller）设计模式是一种广泛应用于软件开发，特别是Web应用开发中的架构模式。它将应用程序分为三个主要部分：模型（Model）、视图（View）和...
Repository实例源代码
03-18
"MVC4Repository+EF实例"则可能是使用ASP.NET MVC4和Entity Framework5.0创建的Repository模式示例，演示了如何在MVC应用中实现数据访问层。 "from.gif"可能是一个说明性的图片，"readme.md"通常包含项目简介和使用...
Mvc.rar_JavaMvc_MVC 数据库_mvc_mvc模式实例
09-19
在这个例子中，开发者可能使用了Spring MVC的`@Service`和`@Repository`注解来定义服务层和数据访问层，`@RequestMapping`来映射HTTP请求。 **总结**： "Mvc.rar_JavaMvc_MVC 数据库_mvc_mvc模式实例"这个压缩包...
mvc模式
12-24
**MVC模式详解** MVC（Model-View-Controller）模式是一种软件设计模式，广泛应用于构建Web应用程序，尤其是在Java、.NET、PHP等后端开发领域。它将应用程序的业务逻辑、用户界面和数据访问分离开来，提高了代码的...
MVC架构中的Repository模式 个人理解
07-22 516
关于MVC架构中的Repository模式 个人理解：Repository是一个独立的层，介于领域层与数据映射层（数据访问层）之间。它的存在让领域层感觉不到数据访问层的存在，它提供一个类似集合的接口提供给领域层进行领域对象的访问。Repository是仓库管理员，领域层需要什么东西只需告诉仓库管理员，由仓库管理员把东西拿给它，并不需要知道东西实际放在哪。 tabbycat的理解（来源）： 1. Repository模式是架构模式，在设计架构时，才有参考价值； 2.Rep...
ASP.NET MVC4+EF系列之六仓储实现 IRepository 和 Repository
weixin_30444105的博客
05-10 258
名词介绍：首先我们必须了解一点领域驱动(DDD)相关知识，至少要对一些名词熟悉，我上传的源代码的注释包含了很多这些名词。例如仓储，仓储上下文,仓储根，领域对象，以及什么领域对象可以考虑作为仓储根。这里我就按我的理解做个粗浅的介绍。不当之处请原谅。比较DDD不是一朝一夕能领悟的东西，需要理论加实践的不断磨合，我这里只是简单的DDD。 　　1.领域对象：就是我们业务中的一个个对象。我想这不用多加解释...
java repository模式_MVC架构中的Repository模式 个人理解
weixin_39683858的博客
02-16 1916
个人理解：Repository是一个独立的层，介于领域层与数据映射层(数据访问层)之间。它的存在让领域层感觉不到数据访问层的存在，它提供一个类似集合的接口提供给领域层进行领域对象的访问。Repository是仓库管理员，领域层需要什么东西只需告诉仓库管理员，由仓库管理员把东西拿给它，并不需要知道东西实际放在哪。1. Repository模式是架构模式，在设计架构时，才有参考价值；2.Reposi...
SpringMVC常用注解@Controller,@Service,@repository,@Component
热门推荐
三分老大爷
06-07 7万+
这两天公司在做一个网站项目，框架使用的是springMVC框架，把常用的几个注解简单整理一下@Controller,@RequestMapping,@Service,@repository,@Autowired,@Component
深入理解MVC架构模式与路由机制
通过以上解释，我们可以看到MVC模式如何在Web应用中组织代码，以及如何通过路由机制处理请求，并利用Repository模式来解耦Controller和业务逻辑。这份笔记为初学者和有经验的开发者提供了深入理解MVC模式和ASP.NET ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值