.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 = 1, int pageSize = 20)
        {
            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();
        }
    }

}

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 = 1, int pageSize = 20);

        void RollBackChanges();
    }

}

需要说明的是，在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 类等内容。准备用下一节的内容来进行整体说明。谢谢。

谢谢。