.netCore+Vue 搭建的简捷开发框架 （3）-- Services层实现

继续交作业：

上一篇作业中我们实现了 Repository仓储层的应用。并为我们的框架引入了EFCore 详见：

.netCore+Vue 搭建的简捷开发框架 （2）--仓储层实现和EFCore 的使用

接下来我们继续来实现Services 层，同样，我们在Services 和IServices 中增加 Base 文件夹。并创建BaseServices.cs 和IBaseServices.cs

如图：

　　

其中BaseServices.cs 和 IBaseServices.cs 代码如下：

 using Sincere.Core.IRepository.Base;
 using Sincere.Core.IServices.Base;
 using Sincere.Core.Model;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlClient;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Sincere.Core.Services.Base
 {
     public class BaseServices<TEntity> : IBaseServices<TEntity> where TEntity : class, new()
     {
         //public IBaseRepository<TEntity> baseDal = new BaseRepository<TEntity>();
         public IBaseRepository<TEntity> BaseDal;//通过在子类的构造函数中注入，这里是基类，不用构造函数
 
         public async Task<int> Del(TEntity model)
         {
            return await BaseDal.Del(model);
         }
 
         public async Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere)
         {
             return await BaseDal.DelBy(delWhere);
         }
 
         public async Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
         {
             return await BaseDal.Execute(sql,parms,cmdType);
         }
 
         public async Task<List<TEntity>> GetList()
         {
            return await BaseDal.GetList();
         }
 
         public async Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda)
         {
             return await BaseDal.GetListBy(whereLambda);
         }
 
         public async Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
         {
             return await BaseDal.GetListBy(whereLambda,orderLambda,isAsc);
         }
 
         public async Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
         {
             return await BaseDal.GetListBy(top, whereLambda, orderLambda, isAsc);
         }
 
         public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
         {
             return await BaseDal.GetListBy( whereLambda, orderLambda1,orderLambda2, isAsc1,isAsc2);
         }
 
         public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
         {
             return await BaseDal.GetListBy(top, whereLambda, orderLambda1, orderLambda2, isAsc1, isAsc2);
         }
 
         public async Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda)
         {
             return await BaseDal.GetModelById( whereLambda);
         }
 
         public async Task<List<TEntity>> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
         {
             return await BaseDal.GetPagedList(pageIndex,pageSize, whereLambda,orderByLambda,isAsc);
         }
 
         public async Task<PageModel<TEntity>> GetPagedList<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true, int pageIndex = , int pageSize = )
         {
             return await BaseDal.GetPagedList(  whereLambda, orderByLambda, isAsc, pageIndex, pageSize);
         }
 
         public async Task<bool> Insert(TEntity model)
         {
             return await BaseDal.Insert(model);
         }
 
         public async Task<bool> InsertRange(List<TEntity> datas)
         {
             return await BaseDal.InsertRange(datas);
         }
 
         public async Task<int> Modify(TEntity model)
         {
             return await BaseDal.Modify(model);
         }
 
         public async Task<int> Modify(TEntity model, params string[] propertyNames)
         {
             return await BaseDal.Modify(model,propertyNames);
         }
 
         public async Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames)
         {
             return await BaseDal.ModifyBy(model, whereLambda,modifiedPropertyNames);
         }
 
         public async Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
         {
             return await BaseDal.Query(sql, parms, cmdType);
         }
 
         public  void RollBackChanges()
         {
               BaseDal.RollBackChanges();
         }
     }
 
 }

BaseServices

 using Sincere.Core.Model;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlClient;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Sincere.Core.IServices.Base
 {
     public interface IBaseServices<TEntity> where TEntity : class
     {
         Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
         Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
         Task<bool> Insert(TEntity model);
         Task<bool> InsertRange(List<TEntity> datas);
 
         Task<int> Del(TEntity model);
 
         Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere);
 
         Task<int> Modify(TEntity model);
 
         Task<int> Modify(TEntity model, params string[] propertyNames);
 
         Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames);
 
         Task<List<TEntity>> GetList();
 
         Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda);
 
         Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda);
 
         Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);
 
         Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);
 
         Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
 
         Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
 
         Task<List<TEntity>> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);
 
         Task<PageModel<TEntity>> GetPagedList<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true, int pageIndex = , int pageSize = );
 
         void RollBackChanges();
     }
 
 }

IBaseServices.cs

需要说明的是，在BaseServices.cs 中我们通过依赖注入的方式引入了IBaseRepository 。

具体的引用需要在子类的构造函数中注入。

结合上一篇中的内容，我们现在的框架就已经搭建好了最基础的框架模型中的Services 和 Repository 层。

为了验证各层之间的调用。接下来我们依旧参照 张老师的课程中使用的Advertisement 类，来进行测试。

我们需要依次建立 Advertisement.cs (Model，已经在上一节中建好) 、IAdvertisementRepository（IRepository 中），AdvertisementRepository（Repository 中）、IAdvertisementServices(IServices中)、AdvertisementServices（Services中）

建好后的代码结构如下：

以后我们在此框架上开发其他服务的时候，也参照这样的目录结构建立相应文件。

接下来依次介绍各个文件，以及其实现过程。

首先是IAdvertisementRepository.cs

这个没什么好说的，继承自 IBaseRepository<Advertisement>。这里面我没有写其他的业务逻辑，是一个空的接口。代码如下：

 using Sincere.Core.IRepository.Base;
 using Sincere.Core.Model.Models;
 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace Sincere.Core.IRepository
 {
     public interface IAdvertisementRepository : IBaseRepository<Advertisement>
     {
 
     }
 }

接下来是AdvertisementRepository.cs ，这里继承自BaseRepository<Advertisement>, 并实现 IAdvertisementRepository接口。代码如下：

 using Sincere.Core.IRepository;
 using Sincere.Core.Model.EFCore;
 using Sincere.Core.Model.Models;
 using Sincere.Core.Repository.Base;
 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace Sincere.Core.Repository
 {
     public class AdvertisementRepository : BaseRepository<Advertisement>, IAdvertisementRepository
     {
         public AdvertisementRepository(IBaseContext mydbcontext) : base(mydbcontext)
         {
 
         }
     }
 }

这里需要说明的是，因为我在BaseRepository 的构造函数中，使用了有参数的构造函数

public BaseRepository(IBaseContext mydbcontext)
{
this._db = mydbcontext as BaseCoreContext;
this._dbSet = _db.Set<TEntity>();
}

所以在AdvertisementRepository  中，将注入的mydbContext 同步注入到BaseRepository 中。

仓储层的逻辑基本就这样了，接下来写Services中的实现。

同样，首先是接口IAdvertisementServices，继承IBaseServices<Advertisement>。没什么好说的，这里为了假装有一个方法，叫做ReadAllAd(),代码如下：

 using Sincere.Core.IServices.Base;
 using Sincere.Core.Model.Models;
 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace Sincere.Core.IServices
 {
     public interface IAdvertisementServices : IBaseServices<Advertisement>
     {
          void ReadAllAd();
     }
 }

最后就是AdvertisementServices了，未来的开发中，我们大部分的业务逻辑都将在这里实现，于仓储层的实现类似，也是继承: BaseServices<Advertisement>, 实现 IAdvertisementServices接口。

代码如下：

 using Sincere.Core.IRepository;
 using Sincere.Core.IRepository.Base;
 using Sincere.Core.IServices;
 using Sincere.Core.Model.Models;
 using Sincere.Core.Services.Base;
 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace Sincere.Core.Services
 {
     public class AdvertisementServices : BaseServices<Advertisement>, IAdvertisementServices
     {
         IAdvertisementRepository _advertisementRepository;
         public AdvertisementServices(IBaseRepository<Advertisement> baseRepository) {
             base.BaseDal = baseRepository;
             _advertisementRepository = baseRepository as IAdvertisementRepository;
         }
         public void ReadAllAd() {
 
         }
     }
 }

这里有些地方需要进行一下说明。首先就是通过依赖注入的方式，将IBaseRepository 注入进来。

在ReadAllAd 方法中的引用如上图所示。

到此为止，各个层中的实现就都完成了。但是我们在Controller 中该怎么引用呢？

这个地方涉及的东西比较多，比如NetCore 的依赖注入、利用反射机制进行注入、NetCore 的Startup.cs 类等内容。准备用下一节的内容来进行整体说明。谢谢。

谢谢。