.NetCore，WebApi简易开发框架搭建

1.首先，新建一个.NetCoreWeb开发项目，选择WebApi

如图所示，新建几个文件夹

本框架使用的ORM为Sqlsugar，直接在依赖项--->管理nuget程序包，搜索Sqlsugar，选择SqlsugarCore，安装

安装好ORM后，我们开始连接数据库

首先写DbContext类

 public class DbContext
    {
        public SqlSugarClient Db;
        public DbContext()
        {
            Db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = ConfigurationManager.Configuration["ConnectionStrings:SqlServerConnection"],
                DbType = DbType.SqlServer,//设置数据库类型
                IsAutoCloseConnection = true,//自动释放数据务，如果存在事务，在事务结束后释放
                InitKeyType = InitKeyType.Attribute //从实体特性中读取主键自增列信息
            });           
        }

        public DbSet<DbModel> GetDb<DbModel>() where DbModel : class, new()
        {
            return new DbSet<DbModel>(Db);
        }
        /// <summary>
        /// 扩展ORM
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class DbSet<T> : SimpleClient<T> where T : class, new()
        {

            public DbSet(SqlSugarClient context) : base(context)
            {

            }
        }
    }

这里ConfigurationManager，是用来处理读取配置文件的，即appsettings.json

public class ConfigurationManager
    {
        public readonly static IConfiguration Configuration;
        static ConfigurationManager()
        {
            Configuration = new ConfigurationBuilder()
             .Add(new JsonConfigurationSource { Path = "appsettings.json", ReloadOnChange = true })
             .Build();
        }
    }

在配置文件里设置数据库连接字符串

接下来我们开始写基础仓储处理

在interface文件夹新建接口IBaseServer接口

public interface IBaseServer<T> where T : class
    {
        /// <summary>
        /// 查询数据不需要任何条件
        /// </summary>
        /// <returns></returns>
        Task<ApiResult<List<T>>> GetListAsync();

        /// <summary>
        /// 添加一条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        Task<ApiResult<string>> AddAsync(T parm);


        /// <summary>
        /// 删除一条或者多条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        Task<ApiResult<string>> DeleteAsync(string parm);

        /// <summary>
        /// 修改一条数据
        /// </summary>
        /// <param name="pram"></param>
        /// <returns></returns>
        Task<ApiResult<string>> UpdateAsync(T pram);

        /// <summary>
        /// 获得一条数据
        /// </summary>
        /// <param name="where">Expression<Func<T, bool>></param>
        /// <returns></returns>
        Task<ApiResult<T>> GetModelAsync(Expression<Func<T, bool>> where);

        /// <summary>
        /// 添加多条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        Task<ApiResult<List<T>>> AddList(List<T> parm);
    }

IBaseServer<T> where T : class ，接口限制传入的必须为类

在BaseServer文件夹新建BaseServer类，这个是对接口的实现

/// <summary>
    /// 学习笔记:
    /// 接口实现要继承数据库上下文类和接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class BaseServer<T> : DbContext, IBaseServer<T> where T : class, new()
    {
        /// <summary>
        /// 简单查询
        /// </summary>
        /// <returns></returns>
        public Task<ApiResult<List<T>>> GetListAsync()
        {
            var res = new ApiResult<List<T>>();//定义res对象
            try
            {
                var query = Db.Queryable<T>().ToList();
                res.success = true;
                res.message = "获得成功";
                res.statusCode = (int)ApiEnum.Error;
                res.data = query;
            }
            catch (Exception ex)
            {
                res.message = ApiEnum.Error.GetEnumText() + ex.Message;
                res.statusCode = (int)ApiEnum.Error;
            }
            return Task.Run(() => res);
        }

        /// <summary>
        /// 插入一条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<ApiResult<string>> AddAsync(T parm)
        {
            //将报错状态重新赋值
            var res = new ApiResult<string>() { statusCode = (int)ApiEnum.Error };
            try
            {
                var dbres = GetDb<T>().Insert(parm);
                if (!dbres)
                {
                    res.message = "添加失败~";
                }
                else
                {
                    res.message = "添加成功~";
                    res.success = true;
                    res.statusCode = (int)ApiEnum.Status;
                }
            }
            catch (Exception ex)
            {
                res.message = ApiEnum.Error.GetEnumText() + ex.Message;
            }
            return await Task.Run(() => res);
        }

        /// <summary>
        /// 删除一条或者多条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<ApiResult<string>> DeleteAsync(string parm)
        {
            var res = new ApiResult<string>() { statusCode = (int)ApiEnum.Error };
            try
            {
                var list = Utils.StrToListString(parm);
                var dbres = GetDb<T>().DeleteByIds(list.ToArray());
                if (!dbres)
                {
                    res.message = "删除数据失败~";
                }
                else
                {
                    res.success = true;
                    res.message = "删除数据成功~";
                    res.statusCode = (int)ApiEnum.Status;
                }
            }
            catch (Exception ex)
            {
                res.message = ApiEnum.Error.GetEnumText() + ex.Message;
            }
            return await Task.Run(() => res);
        }

        /// <summary>
        /// 更新一条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<ApiResult<string>> UpdateAsync(T parm)
        {
            var res = new ApiResult<string>() { statusCode = (int)ApiEnum.Error };
            try
            {
                var dbres = GetDb<T>().Update(parm);
                if (!dbres)
                {
                    res.message = "修改数据失败~";
                }
                else
                {
                    res.success = true;
                    res.message = "修改数据成功~";
                    res.statusCode = (int)ApiEnum.Status;
                }
            }
            catch (Exception ex)
            {
                res.statusCode = (int)ApiEnum.Status;
                res.message = ApiEnum.Error.GetEnumText() + ex.Message;
            }
            return await Task.Run(() => res);
        }


        /// <summary>
        /// 获得一条数据
        /// </summary>
        /// <param name="where">Expression<Func<T, bool>></param>
        /// <returns></returns>
        public async Task<ApiResult<T>> GetModelAsync(Expression<Func<T, bool>> where)
        {
            var model = GetDb<T>().GetSingle(where);
            var res = new ApiResult<T>
            {
                statusCode = 200,
                data = model ?? new T() { }
            };
            return await Task.Run(() => res);
        }

        /// <summary>
        /// 插入多条数据
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<ApiResult<List<T>>> AddList(List<T> parm)
        {
            //将报错状态重新赋值
            var res = new ApiResult<List<T>>() { statusCode = (int)ApiEnum.Error };
            try
            {

                var dbres = Db.Insertable(parm).ExecuteCommand();
                if (dbres == 0)
                {
                    res.message = "添加失败~";
                }
                else
                {
                    res.message = "添加成功~,添加了" + dbres + "条";
                    res.success = true;
                    res.statusCode = (int)ApiEnum.Status;
                }
            }
            catch (Exception ex)
            {
                res.message = ApiEnum.Error.GetEnumText() + ex.Message;
            }
            return await Task.Run(() => res);
        }
    }

接口和实现类写好以后我们需要再startup文件进行接口的注册

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
            //接口注册
            services.AddTransient<ITUserAuthsService, TUserAuthsService>();
           
        }

接口注册完成之后，我们需要新建控制器了，通过沟槽函数的形式实现接口的注入，注入后，写个方法跑一下

 public class LoginController : ControllerBase
    {
        private readonly ITUserAuthsService _tUserAuthsService;

        public LoginController(ITUserAuthsService tUserAuthsService)
        {
            _tUserAuthsService = tUserAuthsService;
        }

        /// <summary>
        /// 用户登陆
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpPost("Login")]
        public async Task<ApiResult<Result>> LoginAsync([FromBody]TUserAuthsLogin parm)
        {

            return await _tUserAuthsService.LoginAsync(parm);
        }
    }