推荐一个API返回的模型

推荐一个API返回的模型

之前加入一个公司，虽然没搞多久，但是发现他们的API的返回模型五花八门，感觉不把前端当人看，一个接口返回多种数据类型，所以就此写了这个文档

using MaintainPhoneAPI.Models;
using System;
using System.Threading.Tasks;

namespace XXXApi
{
    public class Result
    {
        /// <summary>
        /// 状态码
        /// </summary>
        public int Code { get; set; } = 200;

        /// <summary>
        /// 消息
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// 同步不需要传入参数且无返回数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static Result ReturnResult<T>(T t, Action<T> func)
        {
            Result result = new Result();
            try
            {
                func(t);
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }

        /// <summary>
        ///异步方法需要传入参数且无返回数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static async Task<Result> ReturnResult<T>(T t, Func<T, Task> func)
        {
            Result result = new Result();
            try
            {
                await func(t);
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ResultModels<T> : Result
    {
        /// <summary>
        /// 需要返回的数据
        /// </summary>
        public T Data { get; set; }

        /// <summary>
        /// 同步需要传入参数
        /// </summary>
        /// <typeparam name="K"></typeparam>
        /// <param name="k"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static ResultModels<T> ReturnResult<K>(K k, Func<K, T> func)
        {
            ResultModels<T> result = new ResultModels<T>();
            try
            {
                result.Data = func(k);
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }

        /// <summary>
        /// 同步不需要传入参数
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public static ResultModels<T> ReturnResult(Func<T> func)
        {
            ResultModels<T> result = new ResultModels<T>();
            try
            {
                result.Data = func();
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }

        /// <summary>
        ///异步需要传入数据有返回数据
        /// </summary>
        /// <typeparam name="K"></typeparam>
        /// <param name="k"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static async Task<ResultModels<T>> ReturnResult<K>(K k, Func<K, Task<T>> func)
        {
            ResultModels<T> result = new ResultModels<T>();
            try
            {
                result.Data = await func(k);
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }

        /// <summary>
        /// 异步不需要传入数据有返回数据
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public static async Task<ResultModels<T>> ReturnResult(Func<Task<T>> func)
        {
            ResultModels<T> result = new ResultModels<T>();
            try
            {
                result.Data = await func();
            }
            catch (BusinessException ex)
            {
                result.Code = ex.Code;
                result.Message = ex.Message;
            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }
            return result;
        }
    }
   public class BusinessException : Exception
    {
        /// <summary>
        /// 报错误信息
        /// </summary>
        public string Mesg { get; set; }

        public int Code { get; set; } = 500;

        public BusinessException(string message) : base(message)
        {
            Mesg = message;
        }

        public BusinessException(string message, int code) : base(message)
        {
            Mesg = message;
            Code = code;
        }
    }
    /// <summary>
    /// 分页数据
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ListResult<T>
    {
        /// <summary>
        /// 集合
        /// </summary>
        public List<T> List { get; set; }

        /// <summary>
        /// 总数
        /// </summary>
        public int Count { get; set; }
    }

    /// <summary>
    /// 通用下拉菜单
    /// </summary>
    public class SelectBox
    {
        /// <summary>
        /// 唯一值 id
        /// </summary>
        public int Key { get; set; }

        /// <summary>
        /// 显示值
        /// </summary>
        public string Value { get; set; }
    }
}

使用方法

异步不需要参数返回数据

 		/// <summary>
        /// 查询部门下拉菜单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<ResultModels<List<SelectBox>>> GetDepartmentSelectBox()
        {
            return await ResultModels<List<SelectBox>>.ReturnResult(async () =>
           {
               return await departmentService.GetDepartmentSelectAsync();
           });
        }

同步不需要参数返回数据

		/// <summary>
        /// 查询部门下拉菜单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async ResultModels<List<SelectBox>> GetDepartmentSelectBox()
        {
            return ResultModels<List<SelectBox>>.ReturnResult(() =>
           {
               return departmentService.GetDepartmentSelect();
           });
        }

异步需要参数返回数据

 		/// <summary>
        /// 查询部门下拉菜单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<ResultModels<List<SelectBox>>> GetEmployeeSelectBox(int? departmentId)
        {
            return await ResultModels<List<SelectBox>>.ReturnResult(departmentId，async o =>
           {
               return await employeeService.GetEmployeeSelectAsync(o);
           });
        }

同步需要参数返回数据

		/// <summary>
        /// 查询部门下拉菜单
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async ResultModels<List<SelectBox>> GetEmployeeSelectBox(int? departmentId)
        {
            return ResultModels<List<SelectBox>>.ReturnResult(departmentId,o =>
           {
               return employeeService.GetEmployeeSelect(o);
           });
        }

异步不需要参数不返回

		/// <summary>
        /// 更新用户
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<Result> UpDateAsync(EmployeeInput input)
        {
            return await Result.ReturnResult(input, async o =>
            {
                await service.UpDateAsync(input);
            });
        }

同步不需要参数不返回

		/// <summary>
        /// 更新用户
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        public async Result UpDate(EmployeeInput input)
        {
            return await Result.ReturnResult(input,  o =>
            {
                 service.UpDate(input);
            });
        }