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

继续交作业：

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

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

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

如图：

　　

 

 

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

  1 using Sincere.Core.IRepository.Base;
  2 using Sincere.Core.IServices.Base;
  3 using Sincere.Core.Model;
  4 using System;
  5 using System.Collections.Generic;
  6 using System.Data;
  7 using System.Data.SqlClient;
  8 using System.Linq.Expressions;
  9 using System.Text;
 10 using System.Threading.Tasks;
 11 
 12 namespace Sincere.Core.Services.Base
 13 {
 14     public class BaseServices : IBaseServices where TEntity : class, new()
 15     {
 16         //public IBaseRepository baseDal = new BaseRepository();
 17         public IBaseRepository BaseDal;//通过在子类的构造函数中注入，这里是基类，不用构造函数
 18          
 19         public async Task<int> Del(TEntity model)
 20         {
 21            return await BaseDal.Del(model);
 22         }
 23 
 24         public async Task<int> DelBy(Expressionbool>> delWhere)
 25         {
 26             return await BaseDal.DelBy(delWhere);
 27         }
 28 
 29         public async Task<int> Execute(string sql, List parms, CommandType cmdType = CommandType.Text)
 30         {
 31             return await BaseDal.Execute(sql,parms,cmdType);
 32         }
 33 
 34         public async Task> GetList()
 35         {
 36            return await BaseDal.GetList();
 37         }
 38 
 39         public async Task> GetListBy(Expressionbool>> whereLambda)
 40         {
 41             return await BaseDal.GetListBy(whereLambda);
 42         }
 43 
 44         public async Task> GetListBy(Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true)
 45         {
 46             return await BaseDal.GetListBy(whereLambda,orderLambda,isAsc);
 47         }
 48 
 49         public async Task> GetListBy(int top, Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true)
 50         {
 51             return await BaseDal.GetListBy(top, whereLambda, orderLambda, isAsc);
 52         }
 53 
 54         public async Task> GetListBy(Expressionbool>> whereLambda, Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
 55         {
 56             return await BaseDal.GetListBy( whereLambda, orderLambda1,orderLambda2, isAsc1,isAsc2);
 57         }
 58 
 59         public async Task> GetListBy(int top, Expressionbool>> whereLambda, Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
 60         {
 61             return await BaseDal.GetListBy(top, whereLambda, orderLambda1, orderLambda2, isAsc1, isAsc2);
 62         }
 63 
 64         public async Task GetModelById(Expressionbool>> whereLambda)
 65         {
 66             return await BaseDal.GetModelById( whereLambda);
 67         }
 68 
 69         public async Task> GetPagedList(int pageIndex, int pageSize, Expressionbool>> whereLambda, Expression> orderByLambda, bool isAsc = true)
 70         {
 71             return await BaseDal.GetPagedList(pageIndex,pageSize, whereLambda,orderByLambda,isAsc);
 72         }
 73 
 74         public async Task> GetPagedList(Expressionbool>> whereLambda, Expression> orderByLambda, bool isAsc = true, int pageIndex = 1, int pageSize = 20)
 75         {
 76             return await BaseDal.GetPagedList(  whereLambda, orderByLambda, isAsc, pageIndex, pageSize);
 77         }
 78 
 79         public async Task<bool> Insert(TEntity model)
 80         {
 81             return await BaseDal.Insert(model);
 82         }
 83 
 84         public async Task<bool> InsertRange(List datas)
 85         {
 86             return await BaseDal.InsertRange(datas);
 87         }
 88 
 89         public async Task<int> Modify(TEntity model)
 90         {
 91             return await BaseDal.Modify(model);
 92         }
 93 
 94         public async Task<int> Modify(TEntity model, params string[] propertyNames)
 95         {
 96             return await BaseDal.Modify(model,propertyNames);
 97         }
 98 
 99         public async Task<int> ModifyBy(TEntity model, Expressionbool>> whereLambda, params string[] modifiedPropertyNames)
100         {
101             return await BaseDal.ModifyBy(model, whereLambda,modifiedPropertyNames);
102         }
103 
104         public async Task> Query(string sql, List parms, CommandType cmdType = CommandType.Text)
105         {
106             return await BaseDal.Query(sql, parms, cmdType);
107         }
108 
109         public  void RollBackChanges()
110         {
111               BaseDal.RollBackChanges();
112         }
113     }
114 
115 }

BaseServices

 1 using Sincere.Core.Model;
 2 using System;
 3 using System.Collections.Generic;
 4 using System.Data;
 5 using System.Data.SqlClient;
 6 using System.Linq.Expressions;
 7 using System.Text;
 8 using System.Threading.Tasks;
 9 
10 namespace Sincere.Core.IServices.Base
11 {
12     public interface IBaseServices where TEntity : class
13     {
14         Task<int> Execute(string sql, List parms, CommandType cmdType = CommandType.Text);
15         Task> Query(string sql, List parms, CommandType cmdType = CommandType.Text);
16         Task<bool> Insert(TEntity model);
17         Task<bool> InsertRange(List datas);
18 
19         Task<int> Del(TEntity model);
20 
21         Task<int> DelBy(Expressionbool>> delWhere);
22 
23         Task<int> Modify(TEntity model);
24 
25         Task<int> Modify(TEntity model, params string[] propertyNames);
26 
27         Task<int> ModifyBy(TEntity model, Expressionbool>> whereLambda, params string[] modifiedPropertyNames);
28 
29         Task> GetList();
30 
31         Task> GetListBy(Expressionbool>> whereLambda);
32 
33         Task GetModelById(Expressionbool>> whereLambda);
34 
35         Task> GetListBy(Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true);
36 
37         Task> GetListBy(int top, Expressionbool>> whereLambda, Expression> orderLambda, bool isAsc = true);
38 
39         Task> GetListBy(Expressionbool>> whereLambda, Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
40 
41         Task> GetListBy(int top, Expressionbool>> whereLambda, Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);
42 
43         Task> GetPagedList(int pageIndex, int pageSize, Expressionbool>> whereLambda, Expression> orderByLambda, bool isAsc = true);
44 
45         Task> GetPagedList(Expressionbool>> whereLambda, Expression> orderByLambda, bool isAsc = true, int pageIndex = 1, int pageSize = 20);
46 
47         void RollBackChanges();
48     }
49 
50 }

IBaseServices.cs

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

 

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

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

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

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

建好后的代码结构如下：

 

 

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

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

首先是IAdvertisementRepository.cs 

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

 1 using Sincere.Core.IRepository.Base;
 2 using Sincere.Core.Model.Models;
 3 using System;
 4 using System.Collections.Generic;
 5 using System.Text;
 6 
 7 namespace Sincere.Core.IRepository
 8 {
 9     public interface IAdvertisementRepository : IBaseRepository
10     {
11 
12     }
13 }

View Code

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

 1 using Sincere.Core.IRepository;
 2 using Sincere.Core.Model.EFCore;
 3 using Sincere.Core.Model.Models;
 4 using Sincere.Core.Repository.Base;
 5 using System;
 6 using System.Collections.Generic;
 7 using System.Text;
 8 
 9 namespace Sincere.Core.Repository
10 {
11     public class AdvertisementRepository : BaseRepository, IAdvertisementRepository
12     {
13         public AdvertisementRepository(IBaseContext mydbcontext) : base(mydbcontext)
14         {
15             
16         }
17     }
18 }

View Code

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

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

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

 

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

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

 1 using Sincere.Core.IServices.Base;
 2 using Sincere.Core.Model.Models;
 3 using System;
 4 using System.Collections.Generic;
 5 using System.Text;
 6 
 7 namespace Sincere.Core.IServices
 8 {
 9     public interface IAdvertisementServices : IBaseServices
10     {
11          void ReadAllAd();
12     }
13 }

View Code

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

代码如下：

 1 using Sincere.Core.IRepository;
 2 using Sincere.Core.IRepository.Base;
 3 using Sincere.Core.IServices;
 4 using Sincere.Core.Model.Models;
 5 using Sincere.Core.Services.Base;
 6 using System;
 7 using System.Collections.Generic;
 8 using System.Text;
 9 
10 namespace Sincere.Core.Services
11 {
12     public class AdvertisementServices : BaseServices, IAdvertisementServices
13     {
14         IAdvertisementRepository _advertisementRepository;
15         public AdvertisementServices(IBaseRepository baseRepository) {
16             base.BaseDal = baseRepository;
17             _advertisementRepository = baseRepository as IAdvertisementRepository;
18         }
19         public void ReadAllAd() {
20 
21         }
22     }
23 }

View Code

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

 

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

 

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

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

 

PS：公司技术转型，近期考虑换工作中。。

谢谢。