.Net6 DI依赖注入

创建服务

新增一个Services文件夹,创建个StudentServices类专门存放学生

 public class StudentServices
    {
        //和控制器时写的一样，把上下文和automapper放进来
        private readonly StudentContext _context;
        private readonly IMapper _mapper;
        public StudentServices(StudentContext context, IMapper mapper)
        {
            _context = context;
            _mapper = mapper;
        } 
     //简单的创建个Get方法
        public  async Task<IEnumerable<StudentDTO>> Get()
        {
            var student = await _context.Student.Include(x=>x.Classes).ToListAsync();
            return _mapper.Map<IEnumerable<StudentDTO>>(student);
        }
    }

在控制器添加服务

简单的创建个Get方法

[HttpGet]
        public async Task<IActionResult> Get()
        {
            var result = await _studentservices.Get();
            if(result.Count()==0||result == null)
            {
                return NotFound("没有数据");
            }
            return  Ok(result) ;
        }

依赖注入

在Program类依赖注入服务

Update

//添加个返回状态类
public class ResultData
    {
        public int Code { get; set; }
        public string Message { get; set; }
    }

public async Task<ResultData> Update(StudentDTO studentDTO)
        {
            var student = _mapper.Map<Student>(studentDTO);
            //查看是否存在用户，有就更新没有就新增
            if (await _context.Student.AnyAsync(x => x.Id.Equals(student.Id)))
            {
                student.Classes = await _context.Set<Classes>().Where(x => x.Id == Guid.Parse(studentDTO.ClassId)).FirstAsync();
                student.AdmissionTime = await _context.Set<Student>().Where(x => x.Id == studentDTO.Id).Select(x => x.AdmissionTime).FirstOrDefaultAsync();
                _context.Student.Update(student);
                await _context.SaveChangesAsync();
                return new ResultData() { Code=200,Message="数据更新成功"};
            }
            else
            {
                //没有就新增
                student.Id = Guid.NewGuid();
                student.Classes = await _context.Set<Classes>().Where(x => x.Id == Guid.Parse(studentDTO.ClassId)).FirstAsync();
                student.AdmissionTime = DateTime.Now;
                await _context.Student.AddAsync(student);
                await _context.SaveChangesAsync();
                return new ResultData() { Code = 200, Message = "数据新增成功" };
            }
        }

[HttpPost]
public async Task<ResultData> Update(StudentDTO stu)
        {
            return await _studentservices.Update(stu);
        }

这样做可以提高代码的可复用性，写一个接口然后再service这里写一个通用的crud等功能的实现，最后各个业务再根据使用的数据实体对数据进行crud，在controller里写各自所需要增加的业务逻辑这样维护性就更高了，当然这里时只写了Student，写死的没有做泛型的写法

如何使用IOC

继上一个说了接口，所以就开始使用了IOC

这次在Services文件夹里创建一个IServices接口，将需要的方法接上去，简单的写两个，先做接口再做实现

public interface IStudentServices
    {
        public Task<ResultData> Update(StudentDTO studentDTO);
        public Task<IEnumerable<StudentDTO>> Get();
​
    }

service继承接口，在program对接口进行依赖注入

builder.Services.AddScoped<IStudentServices, StudentServices>();

控制器也进行更改

依赖注入类

如果业务一多起来，一直添加进Program的话就会很臃肿，不好维护，所以创建一个依赖注入类来存放

新建个InjectionHelp.cs，方法和类都是静态的

public static class InjectionHelp
    {
        public static void Injection(this IServiceCollection services)
        {
            #region 学生
            services.AddScoped<IStudentServices, StudentServices>();
            #endregion
        }
    }

在Program.cs里写入，就可以了哇哦又学会了，不过现在还用不了，以后做了泛型接口再使用，先保留了解一下，然后再把具体实现写在Repository，Service再调用一下

builder.Services.Injection();

Repository

之前一直做的都是Student，这次多分了个Repository层出来，作为具体的实现，Service作为mapper处理，BaseController做通用控制器，Controller继承上一个，然后根据业务实际对接口进行更细的业务实现，先欠着，写完身分验证先

不是所有的项目都要分的越细越好，要根据实际情况使用合适的设计模式进行分层