Wpf 使用 Prism 实战开发Day12

待办事项接口增删（CURD）改查实现

一.添加待办事项控制器（ToDoController）

1. 控制器类需要继承 ControllerBase 基类
2. 需要添加 [ApiController] 特性以及 [Route] 特性
3. Route（路由） 特性参数规则，一般写法是 [Route("api/[controller]/[action]")] 。也就是路由访问路径：前缀api/当前控制器/具体的方法

---

 二.封装服务共用类以及ToDoController 控制器逻辑实现

• 为了业务处理逻辑和控制器之间实现解耦。可以通过设计：1.通用接口状态返回值类，2.共用（CURD）基础接口类，3.以及各自业务逻辑处理服务类。
• 通用接口状态返回值类提供给共用基础接口类使用。共用基础接口类提供给不同的业务处理服务类使用。然后不同服务类提供给不同控制器进行访问使用。这样就能实现服务与控制器的之间解耦。

1.创建通用接口状态返回值（ApiResponse）类 

• ApiResponse 类的构造函数用来构造返回，成功或失败的结果

 public class ApiResponse
 {
     /// 

     /// 失败
     /// 
     /// 
     /// 
     public ApiResponse(string message, bool status = false)
     { 
         this.Message = message;
         this.Status = status;
     }
     /// 

     /// 成功
     /// 
     /// 
     /// 
     public ApiResponse(bool status,object result) 
     {
       this.Status = status;
       this.Result = result;
     }
     /// 

     /// 返回消息
     /// 
     public string Message { get; set; }

     /// 

     /// 返回状态
     /// 
     public bool Status { get; set; }

     /// 

     /// 结果
     /// 
     public object Result { get; set; }
 }

---

2.创建一个共用的基础接口 增删改查（CURD） IBaseService 基类。

• IBaseService 基类，设计传入一个泛型 T。
• 设计的是异步实现，定义的方法需按照规范，后缀添加Async

    public interface IBaseService
    {
        /// 

        /// 获取全部数据
        /// 
        /// 
        Task GetAllAsync();
        /// 

        /// 根据id，获取单条数据
        /// 
        /// 
        /// 
        Task GetSingleAsync(int id);
        /// 

        /// 添加数据，传入T泛型实体
        /// 
        /// 
        /// 
        Task AddAsync(T model);
        /// 

        /// 更新
        /// 
        /// 
        /// 
        Task UpdateAsync(T model);
        /// 

        /// 删除，根据id进行删除
        /// 
        /// 
        /// 
        Task DeleteAsync(int id);
    }

---

3.创建待办事项接口服务类（IToDoService），继承自共用的 IBaseService 接口类

• 当前待办事项接口服务类（IToDoService），继承了IBaseService 基类后，需要传入泛型实体（待办事项实体） ToDo
• 如果是忘备录接口服务类，就需要传入 Memo 实体了，也就是不同的实现，需传入不同的泛型实体，实现不同的逻辑。

    public interface IToDoService:IBaseService
    {

    }

---

4.接着，创建待办事项服务实现类（ToDoService），实现基类定义的方法逻辑。

/// 

/// 待办事项的实现
/// 
public class ToDoService : IToDoService
{
    private readonly IUnitOfWork work;

    public ToDoService(IUnitOfWork work)
    {
        this.work = work;
    }
    public async Task AddAsync(ToDo model)
    {
        try
        {
            await work.GetRepository().InsertAsync(model);
            if (await work.SaveChangesAsync() > 0) //保存成功
            {
                return new ApiResponse(true, model); //返回true，并把添加的实体返回
            }
            return new ApiResponse("添加数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task DeleteAsync(int id)
    {
        try
        {
            var repository= work.GetRepository();//获取仓储
            //删除之前，先进行查询
            var todo = await repository.GetFirstOrDefaultAsync(predicate:x=>x.Id.Equals(id));
            repository.Delete(todo);
            if (await work.SaveChangesAsync() > 0) //删除成功
            {
                return new ApiResponse(true, "删除成功"); 
            }
            return new ApiResponse("删除数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task GetAllAsync()
    {
        try
        {
           var todos= await work.GetRepository().GetAllAsync();
            return new ApiResponse(true, todos); //返回true，并返回所有数据
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task GetSingleAsync(int id)
    {
        try
        {
           var todo= await work.GetRepository().GetFirstOrDefaultAsync(predicate: x => x.Id.Equals(id));
            return new ApiResponse(true, todo); //把找到的数据返回
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task UpdateAsync(ToDo model)
    {
        try
        {
            var repository = work.GetRepository();//获取仓储
            //更新之前，先拿到要更新的数据
            var todo = await repository.GetFirstOrDefaultAsync(predicate: x => x.Id.Equals(model.Id));
            todo.Title = model.Title;
            todo.Content = model.Content;
            todo.Status = model.Status;
            todo.UpdateDate = DateTime.Now;
            repository.Update(todo);
            if (await work.SaveChangesAsync() > 0) //更新成功
            {
                return new ApiResponse(true, "更新成功");
            }
            return new ApiResponse("更新数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }
}

---

5.完成上述步骤后，还需要在Program.cs 中进行依赖注入。

AddTransient 是生命周期函数，还有AddScoped，AddSingleton 等三种生命周期。

builder.Services.AddTransient();

---

6.最后在 ToDoController 控制器构造函数中，注入 IToDoService 服务进行使用。

[FromBody] 是用于从Http请求的正文中 提取数据的属性。当在接口方法的参数前加上该标记时，web api 框架就会从http请求的正文中，提取请求的json数据并将其绑定到对应的参数上面。

    [ApiController]
    [Route("api/[controller]/[action]")]
    public class ToDoController:ControllerBase
    {
        private readonly IToDoService service;

        public ToDoController(IToDoService service)
        {
            this.service = service;
        }

        [HttpGet]
        public async Task Get(int id)=> await service.GetSingleAsync(id);

        [HttpGet]
        public async Task GetAll() => await service.GetAllAsync();

        [HttpPost]
        public async Task Add([FromBody]ToDo model) => await service.AddAsync(model);

        [HttpPost]
        public async Task Update([FromBody] ToDo model) => await service.UpdateAsync(model);

        [HttpDelete]
        public async Task Delete(int id) => await service.DeleteAsync(id);
    }