基于EF的一个简单实战型分层架构

注：此博客仅适合于刚入门的asp.net core初学者，仅做参考。

 

学了3个月的asp.net core，将之前一个系统（）的php后端用asp.net core重写了一遍， （注：是日本服务器，比较慢），刚入门时，我是想用ddd或abp这种高大上的框架来重写我之前的系统，后面我发现这些概念对我这个刚入门的初学者来说，理解起来还是有点困难，也可能我经历系统还是比较简单，用这些框架反而会比较麻烦。

代码：https://github.com/caijt/itsysaspnetcore

以下是我的分层图，非常简单的分层，连标准三层都不是，用了ef我觉得respository仓储层没必要，如果是用sql或dapper的话，就会加个respository层

itsys：ui层，asp.net core 项目类型为webapi接口

itsys.dto：数据传输对象

itsys.entity：实体层，一般是一个实体对应数据库一个表，也有一个实体对应视图

itsys.entityframework：ef core层

itsys.service：服务层，封装了几个主要service基层，里面主要封装了getlist（获取列表）、getpagelist（获取分页列表）、create（创建实体）、update（更新实体）、delete（删除实体）通用方法，实体的service类只要继承了某个service类，就具备了getlist、getpagelist等方法了。

 

用框架的目标都是一致的，不写重复的代码！对于框架，我的理解就是把通用的重复的代码提取出来，写成一个基类，然后在那么需要个性化的地方挖坑，派生类中再对这些坑进行补充，这样就实现了每个派生类有基类的通用代码，也能有派生类独特的代码。每个派生类只写跟别人不一样的代码，不写重复性代码。

可能说得还不太能准确表达我想说的意思，下面以代码展示。

 

例如查询列表getlist功能，我用ef的话，那我it资产及it合同的service类，需要这样写

//it资产查询列表方法
public list<itassetdto> getlist(itassetquerydto queryparams)
{
    var query = dbcontext.set<itasset>().asqueryable();

    query = query.include(e => e.createuser);

    #region 资产编号
    if (!string.isnullorwhitespace(queryparams.no))
    {
        query = query.where(e => e.no.contains(queryparams.no));
    }
    #endregion
    #region 资产型号
    if (!string.isnullorwhitespace(queryparams.model))
    {
        query = query.where(e => e.no.contains(queryparams.model));
    }
    #endregion
    #region 标识号
    if (!string.isnullorwhitespace(queryparams.diy_no))
    {
        query = query.where(e => e.diy_no.contains(queryparams.diy_no));
    }
    #endregion
    if (queryparams.sortorder == "no")
    {
        query = query.orderby(e => e.no);
    }
    if (queryparams.sortorder == "inbound_date")
    {
        query = query.orderby(e => e.inbound_date);
    }
    return query.select(e => new itassetdto
    {
        no = e.no,
        inbound_date = e.inbound_date,
        id = e.id
    })
    .tolist();
}

 

//it合同查询列表方法
public list<itcontractdto> getlist(itcontractquerydto queryparams)
{
    var query = dbcontext.set<itcontract>().asqueryable();

    query = query.include(e => e.createuser).include(e=>e.supplier);

    #region 合同编号
    if (!string.isnullorwhitespace(queryparams.no))
    {
        query = query.where(e => e.no.contains(queryparams.no));
    }
    #endregion
    #region 合同名称
    if (!string.isnullorwhitespace(queryparams.name))
    {
        query = query.where(e => e.name.contains(queryparams.name));
    }
    #endregion
    return query.select(e => new itcontractdto
    {
        no = e.no,
        name = e.name,
        id = e.id
    })
    .tolist();
}

有没有从其中发现一些重复，但又不重复的地方，重复的是 dbcontext.set<实体>().include().where().orderby().select().tolist()；不同的是每个实体表它的where、include、orderby、select都不太一样。那我就在这些地方挖坑。

 

如下代码，我定义了一个基类，里面有selectexpression、 oninclude、onwhere、orderprop属性，这些都是我挖的坑，哈哈。然后定义了一个通用的getlist方法，那么派生类继承于这个基类后，不用写任何方法，就有了通用的getlist方法，如果需要具有字段查询功能或字段排序功能的话，就在派生类的构造方法里对这些坑进行赋值。

using automapper;
using itsys.dto;
using itsys.entityframework;
using microsoft.entityframeworkcore;
using system;
using system.collections.generic;
using system.linq;
using system.linq.expressions;
using system.text;

namespace itsys.service.base
{
    public class baseservice<tentity, tdto, tquerydto>
        where tentity : class
        where tquerydto : iquerydto
    {
        protected itsysdbcontext dbcontext;
        protected imapper mapper;

        /// <summary>
        /// 实体转化为dto对象的表达式
        /// </summary>
        protected expression<func<tentity, tdto>> selectexpression { get; set; }

        /// <summary>
        /// 构建include关联属性数据
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        protected func<iqueryable<tentity>, iqueryable<tentity>> oninclude { get; set; }

        /// <summary>
        /// 构建where查询
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        protected func<iqueryable<tentity>, tquerydto, iqueryable<tentity>> onwhere { get; set; }
        /// <summary>
        /// 根据排序字段的字符串返回一个排序表达式
        /// </summary>
        protected func<string, expression<func<tentity, dynamic>>> orderprop { get; set; }

        public baseservice(itsysdbcontext dbcontext, imapper mapper)
        {
            this.dbcontext = dbcontext;
            this.mapper = mapper;
            selectexpression = e => mapper.map<tdto>(e);
        }
        protected list<tdto> getlist(tquerydto queryparams)
        {
            var query = dbcontext.set<tentity>().asnotracking();

            #region 加载导航属性
            if (oninclude != null)
            {
                query = oninclude(query);
            }
            #endregion

            #region 查询条件
            if (onwhere != null)
            {
                query = onwhere(query, queryparams);
            }
            #endregion

            #region 排序
            var exp = orderprop != null ? orderprop(queryparams.orderprop) : null;
            if (exp != null)
            {
                query = queryparams.orderdesc.getvalueordefault(true) ? query.orderbydescending(exp) : query.orderby(exp);
            }
            #endregion

            return query.select(selectexpression).tolist();
        }
    }
}

 下面是上面代码iquerydto对象接口的定义代码

namespace itsys.dto
{
    public interface iquerydto
    {
        /// <summary>
        /// 每页数量
        /// </summary>
        int pagesize { get; set; }
        /// <summary>
        /// 当前页
        /// </summary>
        int currentpage { get; set; }/// <summary>
        /// 排序字段
        /// </summary>
        string orderprop { get; set; }
        /// <summary>
        /// 是否倒序排序
        /// </summary>
        bool? orderdesc { get; set; }        
    }
}

 

现在的it资产的service类就可以很简单了，继承baseservice，泛型类型第一个是实体类型itasset，第二个是对应的dto对象itassetdto，第三个是实现了iquerydto接口的查询参数对象itassetquerydto，然后不用写一个方法，只要在构造方法里对onwhere、orderprop及selectexpression属性配置就好了。

using system;
using system.collections.generic;
using system.linq;
using system.text;
using automapper;
using itsys.dto;
using itsys.entity;
using itsys.entityframework;
using itsys.service.base;

namespace itsys.service.it
{
    public class itassetservice : baseservice<itasset, itassetdto, itassetquerydto>
    {
        public itassetservice(itsysdbcontext dbcontext, imapper mapper) : base(dbcontext, mapper)
        {
            //定义where的坑
            onwhere = (query, queryparams) =>
            {
                #region 资产编号
                if (!string.isnullorwhitespace(queryparams.no))
                {
                    query = query.where(e => e.no.contains(queryparams.no));
                }
                #endregion
                #region 资产型号
                if (!string.isnullorwhitespace(queryparams.model))
                {
                    query = query.where(e => e.no.contains(queryparams.model));
                }
                #endregion
                return query;
            };
            //定义order的坑
            orderprop = prop =>
            {
                switch (prop)
                {
                    case "create_time":
                        return e => e.createtime;
                    case "update_time":
                        return e => e.updatetime;
                    case "no":
                        return e => e.no;
                }
                return null;
            };
            //定义select的坑
            selectexpression = e => new itassetdto
            {
                id = e.id,
                no = e.no,
                model = e.model
            };
        }
    }
}

 

按照这个思路，给create，update，delete方法也挖坑，我是在三个方法的之前跟之后分别挖了两个坑，因为有些实体创建时我需要给某些字段定义初始值，例如create_time字段，我可以在onbeforecreate给实体初始化create_time值，有些实体我需要在更新时定义字段值，例如update_time，我在onbeforeupdate初始化update_time的值，有些实体的删除，我需要在删除之前查询此实体跟其它表还有没有关联，我可以在onbeforedelete中查询。

下面以create代码为例

protected action<tentity, tcreatedto> onbeforecreate { get; set; }
protected action<tentity, tcreatedto> onaftercreate { get; set; }

/// <summary>
/// 创建实体
/// </summary>
/// <returns></returns>
public virtual tdto create(tcreatedto createdto)
{
    var entity = mapper.map<tentity>(createdto);
    if (onbeforecreate != null)
    {
        onbeforecreate(entity, createdto);
    }
    dbset.add(entity);
    dbcontext.savechanges();
    if (onaftercreate != null)
    {
        onaftercreate(entity, createdto);
    }
    return mapper.map<tdto>(entity);
}

 

如果从github下载了我的代码看后会发现里面的代码跟上面的代码还有很大差别，因为我把方法拆得更细，主要考虑一些特殊情况，方法拆细点，可以实现更多特殊操作，不过思路是一样的，都是按上面的方式，在适合的地点挖坑。

 

介绍我这几个主要的service基类，我是实体的一些通用特点（例如说某些实体都有id主键，某些实体都有create_time、update_time字段）进行定义的

viewservice<tviewentity, tdto, tquerydto>：这个主要用于视图查询，没有增删改操作；

entityviewservice<tentity,tviewentity,tdto,tcreatedto,tupdatedto,tquerydto> ：需定义实体与视图实体，因为我有一些实体的查询列表会比较麻烦，比如查询时还要统计某些关联记录的值，在ef中查询起来很不方便，所以在数据库再创建对应的视图查询，同时在系统中定义对应的视图实体，实体就用来增删改，视图实体就用来查；

entityservice<tentity, tdto, tcreatedto, tupdatedto, tquerydto> ：当实体的查询列表没那么复杂时，可只定义一个实体，也就是实体跟视图实体是一致的

identityviewservice<tentity, tviewentity,tdto,tcreatedto,tupdatedto,tquerydto> ：实体都具有id主键，这个基类里默认会对id主键字段进行统一的配置，例如默认对id排序

identityservice<tentity, tdto, tcreatedto, tupdatedto, tquerydto> ：不需要额外定义视图实体

 auditviewservice<tentity, tviewentity, tdto, tcreatedto, tupdatedto, tquerydto> ：实体都具有主键id字段、create_time字段、create_user_id字段、update_time字段、update_user_id字段，这个基层默认会在创建时更新时对create_time、update_time字段进行赋值以及排序字段的配置；

auditservice<tentity, tdto, tcreatedto, tupdatedto, tquerydto>：不需要额外定义视图实体

auditcompanyviewservice<tentity, tviewentity, tdto, tcreatedto, tupdatedto, tquerydto>：在auditviewservice的基础上，实体还具有company_id字段，因为我的系统里，很多数据都是需要根据当前登录用户的所具有公司管理权限过滤相应的数据，这个service默认会在查询时进行company_id字段的过滤

auditcompanyservice<tentity, tdto, tcreatedto, tupdatedto, tquerydto>：不需要额外定义视图实体

 

写到后面，发现有点乱了，不知怎么表达我想表达的东西了，就这样吧，也不是多么有技术含量的设计，有兴趣地看我代码吧。