上传Git的忽略文件下载

千万不能忘记配置忽略文件，不然可能会搞得你一个项目10多个G，很烦人

---

先梳理下我们需要新建的项目如下。接口层一般I(i)开头，实现层不需要。后面还会增加扩展类或者其他的。

API程序层：FastEasyAPI

服务接口层：FastEasy.IService

服务实现层：FastEasy.Service

仓储接口层：FastEasy.IRepository

仓储实现层：FastEasy.Repository

实体层：FastEasy.Model

仓储模式的介绍很多大佬都有博客可以了解，我不会说什么太专业的词汇表达，我也记不得，我会按照我自己的理解来形容

首先，仓储层(接口+实现)，服务层(接口+实现)，API程序层。这算是三层的结构，如果熟练或者精通了，不用建这么多类库，接口实现层可以合并或者使用泛型仓储…让项目短小精悍，不过目前我还理解不够，所以搭建最基础的仓储模式。

接下来应该去添加访问数据库的对象

这个就有很多选择了。Ado，ef，Sqlsugar等等。我刚出来工作的时候学的ado和ef，现在的话……唉，正如前文所说，一路cv过来的，现在都忘的差不多了。所以我选择Sqlsugar！推荐！很棒！反正公司老项目就用他们封装好的ef或者ado，如果有新项目需求，我都用sqlsugar，真的好用一批~特别是多租户事务之类的，我很喜欢~（有点跑题了，继续……）

原本我打算直接用来着，后来突然想起来，咱们都core了，怎么可以不用依赖注入呢？所以嘞，这里先穿插一下Autofac的使用，因为之前我单独写过autofac的教程，所以可能我会粘贴之前的文章内容，不懂的话可以留言或者百度，面向百度编程，是你最好的选择！

Autofac的使用 Sqlsugar的注入使用

在api程序层引入autofac的包：Autofac.Extensions.DependencyInjection（内置依赖包含了autofac的基础包）

这里说下经验之谈，也不是我自己的经验，就是随着项目越来越大，Programs里面的服务注册会越来越多，所有我要在程序下面新建一个文件夹Filter，里面放我的各个模块的注册类，例如我要注入Sqlsugar，那我会在filter文件夹下新建一个类，起名：SqlsugarModule。然后关于Sqlsugar的注入配置都写在此处，然后Programs里直接注入这个类就行，这样后期不会因为注入很多东西导致Programs过于臃肿。

引入Sqlsugar 的包：SqlSugarCore。第一次接触的话推荐大家去官网学习

  Services.AddSingleton<ISqlSugarClient>(s =>
        {
            SqlSugarScope db = new(new ConnectionConfig()
            {
                DbType = SqlSugar.DbType.Sqlite,
                ConnectionString = "DataSource=sqlsugar-dev.db",
                IsAutoCloseConnection = true,
            });
            return db;
        });

scope单例注入，client非单例注入。官网的介绍是scope线程安全，排查问题方便，client非单例模式，性能比scope高5%左右。我是觉得性能差不多，scope可以让我省心很多，嘿嘿嘿。

到这里的话，sqlsugar其实已经注入完成了，就是这么简单，操作比ef方便很多啊，不过这种东西都是唯手熟尔，哪个你用着6就用哪个

创建基础Base基类

写到这儿发现前面的autofac说早了。抱歉各位。因为sqlsugar实在是很简单，所以完全不需要用到autofac（笑死），不过都这样了，就没办法了，反正下面肯定会再说autofac的使用的。

上面注入了Sqlsuar的服务，代表着我们可以访问数据库了。

众所周知，所有的功能需求到最后无非都是对数据库的增删改查，我们先不讨论你业务逻辑怎么搞，到最后你无非都是要搞一个实体，对数据库新增，或者修改，或者搞一个id对着数据库删除数据。因此，无论你操作哪个表，都离不开这些增删改查，所以这个Base基层，就是所有基础的增删改查，分页查询等。

简单梳理下结构，首先我们有仓储层，服务层，应用程序层。仓储层和服务层都各有一个接口层和实现层。最基本的要新增4个类：IBaseRepository，BaseRepository。IBaseService，BaseRepository。因为对数据访问在仓储层，所以我们从Repository开始新建起：先接口后实现。（Base基层的仓储层和服务层基本上一模一样，其方法也只是满足基本的增删改查需求，若是复杂逻辑还需将基类定义为虚方法，在每张表独立的仓储层和服务层去重写方法）

基础方法囊括：单条增删改查，批量增删改查，分页查询

这是仓储层的Base基类接口

    /// <summary>
    /// 1条新增
    /// </summary>
    /// <param name="entity">要创建的实体对象</param>
    /// <returns>如果成功创建实体记录，则返回 true；否则返回 false。</returns>
    Task<bool> CreateEntityAsync(T entity);

    /// <summary>
    /// 批量新增
    /// </summary>
    /// <param name="entities">要新增的实体对象集合</param>
    /// <returns>新增操作影响的记录条数</returns>
    Task<int> CreateEntitysAsync(List<T> entitys);

    /// <summary>
    /// 1条修改
    /// </summary>
    /// <param name="entity">要修改的实体对象</param>
    /// <returns>如果成功修改实体记录，则返回 true；否则返回 false。</returns>
    Task<bool> UpdateEntityAsync(T entity);

    /// <summary>
    /// 批量修改
    /// </summary>
    /// <param name="entities">要修改的实体对象集合</param>
    /// <returns>受影响的记录数</returns>

    Task<int> UpdateEntitysAsync(List<T> entitys);

    /// <summary>
    /// 1条删除
    /// </summary>
    /// <param name="id">要删除的记录的主键ID。</param>
    /// <returns>删除操作影响的记录数。</returns>
    Task<bool> DeleteEntityByIdAsync(int id);

    /// <summary>
    /// 根据条件批量删除
    /// </summary>
    /// <param name="expression">条件</param>
    /// <returns>返回受影响条数</returns>
    Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression);

    /// <summary>
    /// 查询所有
    /// </summary>
    /// <returns>返回实体集合</returns>
    Task<List<T>> GetEntitysAsync();

    /// <summary>
    /// 根据ID单条查询
    /// </summary>
    /// <param name="id">主键ID</param>
    /// <returns>查询到的实体</returns>
    Task<T> GetEntityByIdAsync(int id);

    /// <summary>
    /// 根据条件批量查询。
    /// </summary>
    /// <param name="expression">条件表达式</param>
    /// <returns>符合条件的实体集合</returns>
    Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression);

    /// <summary>
    /// 分页查询
    /// </summary>
    /// <param name="pageNumber">页码，从1开始</param>
    /// <param name="pageSize">每页条数</param>
    /// <param name="totalCount">总记录数</param>
    /// <returns>查询到的实体集合</returns>
    Task<List<T>> GetEntitysToPageAsync(int pageNumber, int pageSize, ref int totalCount);

View Code

这是仓储层Base基类实现。实现的是上面定义的Base基类接口

public class BaseRepository<T> : IBaseRepository<T> where T : class, new()
{
    #region 构造

    public BaseRepository(ISqlSugarClient _db)
    {
        db = _db;
    }

    #endregion 构造

    protected readonly ISqlSugarClient db;

    public virtual async Task<bool> CreateEntityAsync(T entity)
    {
        try
        {
            return await db.Insertable<T>(entity).ExecuteCommandAsync() > 0;
        }
        catch (Exception)
        {
            return false;
        }
    }

    public virtual async Task<int> CreateEntitysAsync(List<T> entitys)
    {
        try
        {
            return await db.Insertable<T>(entitys).ExecuteCommandAsync();
        }
        catch (Exception)
        {
            return 0;
        }
    }

    public virtual async Task<bool> DeleteEntityByIdAsync(int id)
    {
        try
        {
            return await db.Deleteable<T>().In(id).ExecuteCommandAsync() > 0;
        }
        catch (Exception)
        {
            return false;
        }
    }

    public virtual async Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression)
    {
        try
        {
            return await db.Deleteable<T>().Where(expression).ExecuteCommandAsync();
        }
        catch (Exception)
        {
            return 0;
        }
    }

    public virtual async Task<T> GetEntityByIdAsync(int id)
    {
        try
        {
            return await db.Queryable<T>().InSingleAsync(id);
        }
        catch (Exception)
        {
            return null;
        }
    }

    public virtual async Task<List<T>> GetEntitysAsync()
    {
        try
        {
            return await db.Queryable<T>().ToListAsync();
        }
        catch (Exception)
        {
            return null;
        }
    }

    public virtual async Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression)
    {
        try
        {
            return await db.Queryable<T>().Where(expression).ToListAsync();
        }
        catch (Exception)
        {
            return null;
        }
    }

    public virtual List<T> GetEntitysToPage(int pageNumber, int pageSize, ref int totalCount)
    {
        try
        {
            return db.Queryable<T>().ToPageList(pageNumber, pageSize, ref totalCount);
        }
        catch (Exception)
        {
            return null;
        }
    }

    public virtual async Task<bool> UpdateEntityAsync(T entity)
    {
        try
        {
            return await db.Updateable<T>(entity).ExecuteCommandAsync() > 0;
        }
        catch (Exception)
        {
            return false;
        }
    }

    public virtual async Task<int> UpdateEntitysAsync(List<T> entitys)
    {
        try
        {
            return await db.Updateable<T>(entitys).ExecuteCommandAsync();
        }
        catch (Exception)
        {
            return 0;
        }
    }
}

View Code

基础的增删改差不多就这么多了。写的时候发现个小问题。就是根据id的增删改查，其实也没必要专门搞个方法，使用条件查询方法就可以了，不过一开始没考虑到，我觉得代码复用性高一点说明写的好，不过我这个并没什么太大影响。继续~~

服务层的Base基类接口，这个完全可以复制仓储层的base基类接口，不能说毫无关系，只能说完全一样，所以这里不写咯。

服务层的Base基类实现，也差不多一样，不同的是仓储层是使用db访问数据库，而服务层是通过构造函数注入仓储层的Base基类接口，通过调用接口方法来进行调用。

public class BaseService<T> : IBaseService<T> where T : class, new()
{
    #region 构造

    public BaseService(IBaseRepository<T> _baseRepository)
    {
        baseRepository = _baseRepository;
    }

    #endregion 构造

    protected readonly IBaseRepository<T> baseRepository;

    public Task<bool> CreateEntityAsync(T entity)
    {
        return baseRepository.CreateEntityAsync(entity);
    }

    public Task<int> CreateEntitysAsync(List<T> entitys)
    {
        return baseRepository.CreateEntitysAsync(entitys);
    }

    public Task<bool> DeleteEntityByIdAsync(int id)
    {
        return baseRepository.DeleteEntityByIdAsync(id);
    }

    public Task<int> DeleteEntitysByWhereAsync(Expression<Func<T, bool>> expression)
    {
        return baseRepository.DeleteEntitysByWhereAsync(expression);
    }

    public Task<T> GetEntityByIdAsync(int id)
    {
        return baseRepository.GetEntityByIdAsync(id);
    }

    public Task<List<T>> GetEntitysAsync()
    {
        return baseRepository.GetEntitysAsync();
    }

    public Task<List<T>> GetEntitysByWhereAsync(Expression<Func<T, bool>> expression)
    {
        return baseRepository.GetEntitysByWhereAsync(expression);
    }

    public List<T> GetEntitysToPage(int pageNumber, int pageSize, ref int totalCount)
    {
        return baseRepository.GetEntitysToPage(pageNumber, pageSize, ref totalCount);
    }

    public Task<bool> UpdateEntityAsync(T entity)
    {
        return baseRepository.UpdateEntityAsync(entity);
    }

    public Task<int> UpdateEntitysAsync(List<T> entitys)
    {
        return baseRepository.UpdateEntitysAsync(entitys);
    }
}

View Code

看到这里的话，基本的仓储模式已经搭建完成了，是的没错，就是这么简单。但是还没有真正的去添加数据库，所以只有基层，像这种普通的仓储模式有个很麻烦的地方就是每一个表结构至少要在项目里添加4个类，所以还是比较麻烦的，所以最近在研究代码生成，网上有很多现成的代码生成器，不过我还是想自己研究研究，为了我这个开源项目的目标！我要搞个适配我这个项目的代码生成器，毕竟自己写的代码我心里有数~

都要一起加油哟~ 掰掰~

---

2023-9-20第一次更新内容：

有小伙伴建议我增加原生Sql的查询，确实如此，所以在写完代码生成的文章后，我又在base基类添加了三个接口，分别是：

1. 原生SQL查询，返回List集合
2. 原生SQL查询，返回Datatable
3. 存储过程查询，返回Datatable