.NET6.0 API仓储+工作单元

最新推荐文章于 2024-08-21 21:21:52 发布

ghost____4

最新推荐文章于 2024-08-21 21:21:52 发布

阅读量445

点赞数 7

文章标签： .net

本文链接：https://blog.csdn.net/ghost____4/article/details/134616750

版权

.NET6.0 API仓储+工作单元

配置数据库

引入依赖包
不同的数据库引入不同：

公共依赖包：

  Microsoft.EntityFrameworkCore
  Microsoft.EntityFrameworkCore.Design
  Microsoft.EntityFrameworkCore.Tools

SqlServer：

  Microsoft.EntityFrameworkCore.SqlServer

Sqlite:
```
  Microsoft.EntityFrameworkCore.Sqlite
```
MySql:
```
  Pomelo.EntityFrameworkCore.MySql
```

配置连接字符串
appsettings.json在这里插入代码片文件中加如下代码

{
  "ConnectionStrings": {
  	//sqlite
    "ToDoConnection": "Data Source=to.db" 
    //sqlserver
    "StudentDBConnection": "server=SKY-20161118TNS\\MYSQL2012;Initial Catalog=StudentDB;User ID=sa;Password=123456"  
    //mysql
    "DBConnection": "Server=195.168.1.21;Port=3306;Database=amicauniqidserver;Uid=root;Pwd=123456;"  
  },
  //mysql同时需要配置版本号
  "Custom": {
	  "mysqlVer": "8.0.28-mysql"
	}
}

Program.cs代码配置

  // 配置数据库，sqlite数据库
builder.Services.AddDbContext<MyToDoContext>(option =>
    {
        var connectionStr = builder.Configuration.GetConnectionString("ToDoConnection");
        option.UseSqlite(connectionStr, b =>
        {
            b.MigrationsAssembly("MyToDoApi");
        });
    })

//配置数据库，sqlserver连接池

//加载sqlserver，采用数据库连接池
 var connectionStr = builder.Configuration.GetConnectionString("ToDoConnection");
builder.services.AddDbContextPool<AppDbContext>(option => 
{
	option.UseSqlServer(connectionStr);
})

//配置数据库，mysql工厂

//加载mysql，采用数据库连接工厂
var connection = host.Configuration.GetConnectionString("DBConnection");
//获取自定义配置参数（mysql版本号）
Config custom = host.Configuration.GetSection("Custom").Get<Config>();
services.AddDbContextFactory<AppDbContext>(
       optionsAction: options => options.UseMySql(connection, new MySqlServerVersion(custom.mysqlVer))
   );

配置工作单元

引入依赖包
Microsoft.EntityFrameworkCore.UnitOfWork
自定义Context类

using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public MyDbContext (DbContextOptions<MyDbContext> optios) : base(optios)
    {

    }

	//以下为数据库表映射实体类的集合
    public DbSet<UserDto> UserDtos { get; set; }
    public DbSet<ToDoDto> ToDoDtos { get; set; }
    public DbSet<MemoDto> MemoDtos { get; set; }
}

配置依赖注入

builder.Services.AddUnitOfWork<MyDbContext>();

构建仓储

分解构建三个实体类的仓储类

using Arch.EntityFrameworkCore.UnitOfWork;

//继承的Repository类来自UnitOfWork包
public class MemoRepository : Repository<MemoDto>
{
    public MemoRepository(MyToDoContext dbContext) : base(dbContext)
    {
         
    }
}

public class ToDoDtoRepository : Repository<ToDoDto>
{
    public ToDoDtoRepository(MyToDoContext dbContext) : base(dbContext)
    {
    }
}

public class UserDtoRepository : Repository<UserDto>
{
    public UserDtoRepository(MyToDoContext dbContext) : base(dbContext)
    {
    }
}

配置依赖注入

//数据库实体类映射各自仓储类
builder.Services
	.AddCustomRepository<ToDoDto, ToDoDtoRepository>()
	.AddCustomRepository<MemoDto, MemoRepository>()
	.AddCustomRepository<UserDto, UserDtoRepository>();

服务层调用

创建统一返回类

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; }
}

创建基础服务接口

//定义服务必备函数
public interface IBaseService<T>
{
	//获取全部
    Task<ApiResponse> GetAllAsync();
	//获取指定Id
    Task<ApiResponse> GetSingleAsync(int id);
	//添加记录
    Task<ApiResponse> AddAsync(T model);
    //更新
    Task<ApiResponse> UpdateAsync(T model);
    //删除指定Id
    Task<ApiResponse> DeleteAsync(int id);

}

//分别创建各仓库对应服务接口
//如下例
public interface IToDoDtoService : IBaseService<ToDoDto>
{
}

创建各仓储服务类

public class ToDoDtoService : IToDoDtoService
{
	//通过工作单元保证混合仓储操作时是统一的DbContext
    private readonly IUnitOfWork _unitOfWork;

    public ToDoDtoService(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

    public async Task<ApiResponse> AddAsync(ToDoDto model)
    {
        try
        {
            await _unitOfWork.GetRepository<ToDoDto>().InsertAsync(model);
            if (await _unitOfWork.SaveChangesAsync() > 0)
                return new ApiResponse(true, model);

            return new ApiResponse("添加数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task<ApiResponse> DeleteAsync(int id)
    {
        try
        {
        	//通过工作单元对象（_unitOfWork）获取仓储
            var repository = _unitOfWork.GetRepository<ToDoDto>();
            var todo = await repository.GetFirstOrDefaultAsync(predicate: t => t.Id == id);

            repository.Delete(todo);

            if (await _unitOfWork.SaveChangesAsync() > 0)
                return new ApiResponse(true, "");

            return new ApiResponse("删除数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task<ApiResponse> GetAllAsync()
    {
        try
        {
            var repository = _unitOfWork.GetRepository<ToDoDto>();
            var todos = repository.GetAll();

            return new ApiResponse(true, todos);
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task<ApiResponse> GetSingleAsync(int id)
    {
        try
        {
            var repository = _unitOfWork.GetRepository<ToDoDto>();
            var todo = await repository.GetFirstOrDefaultAsync(predicate: t => t.Id == id);

            return new ApiResponse(true, todo);
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public async Task<ApiResponse> UpdateAsync(ToDoDto model)
    {
        try
        {
            var repository = _unitOfWork.GetRepository<ToDoDto>();
            var todo = await repository.GetFirstOrDefaultAsync(predicate: t => t.Id == model.Id);

            todo.Title = model.Title;
            todo.UpdateDate = DateTime.Now;
            todo.Status = model.Status;
            todo.Content = model.Content;
            repository.Update(todo);

            if (await _unitOfWork.SaveChangesAsync() > 0)
                return new ApiResponse(true, todo);

            return new ApiResponse("更新数据失败");
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }

    public ApiResponse GetAll()
    {
        try
        {
            var repository = _unitOfWork.GetRepository<ToDoDto>();
            var todos = repository.GetAll();

            return new ApiResponse(true, todos);
        }
        catch (Exception ex)
        {
            return new ApiResponse(ex.Message);
        }
    }
}

Controllers中调用服务

例：

[Route("api/[controller]/[action]")]
[ApiController]
public class ToDoDtoController : ControllerBase
{
    private readonly IToDoDtoService _toDoDtoService;
    public ToDoDtoController(IToDoDtoService toDoDtoService)
    {
        _toDoDtoService = toDoDtoService;
    }

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

    [HttpGet]
    public async Task<ApiResponse> GetAll() => await _toDoDtoService.GetAllAsync();

    [HttpPost]
    public async Task<ApiResponse> Add([FromBody] ToDoDto param) => await _toDoDtoService.AddAsync(param);

    [HttpPost]
    public async Task<ApiResponse> Update([FromBody] ToDoDto param)=>await _toDoDtoService.UpdateAsync(param);

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