如何在我的 ASP.NET 核心 Web API 项目中使用工作单元模式和通用存储库模式？

Question

inte.net 上有很多关于一起使用工作单元和通用存储库的示例，但我找不到确切的如何将工作单元存储库模式应用到我自己的项目中。 因为每个人做的都不一样。

实际上，我设置了工作单元结构，但我不太明白如何在我自己的项目中使用它？ 如何将我创建的工作单元存储库应用到我自己的项目中？ 你能帮我吗？ 如果我有错误，你能告诉我吗？ 这就是我在 inte.net 上看到工作单元存储库并实现它的方式。

首先，如果我只说我的项目，我的项目是一个 ASP.NET Core Web API 项目，基本上是一个 3 层结构：

1. API层。 我在 API 层有控制器。
2. 其次是业务层。 业务层仅用于与数据访问层进行通信。
3. 第三层是数据访问层，在这一层我做数据库的操作，比如增删改查。

我正在使用通用存储库执行这些操作。 例如，我在下面分享我的一些代码。

我只是以共享类别为例，但我有多个 class 喜欢的类别。

API 层 - CategoriesController控制器：

[Route("api/[controller]")]
[ApiController]
public class categoriesController : ControllerBase
{
    private ICategoryService category_service;
    DatabaseContext c = new DatabaseContext();

    public categoriesController(ICategoryService category_service)
    {
        this.category_service = category_service;
    }
   
    [HttpGet("getall")]
    public async Task<IActionResult> Get()
    {
        return Ok(await category_service.TGetAll());
    }

    [HttpGet("getbyid/{id}")]
    public async Task<IActionResult> GetByIdCategory(int id)
    {
        var category = await category_service.TGetById(id);

        if (category != null)
        {
            return Ok(category);  // 200 ok
        }
        else
        {
            return NotFound(); //404 not found
        }
    }

    [HttpPost("add")]
    public async Task<IActionResult> Add(Category category)
    {
        var result =  category_service.TAdd(category);

        if (result != null)
        {
            return Ok(result);
        }

        return BadRequest(result);
    }
}

业务层CategoryManager ：

public class CategoryManager:ICategoryService
{
    ICategoryDal _categoryDal;
       
    public CategoryManager(ICategoryDal _cateogoryDal)
    {
        this._categoryDal = _cateogoryDal;
    }

    public async Task<List<Category>> TGetAll()
    {
        return await _categoryDal.GetListAll();
    }

    public async Task<Category> TGetById(int id)
    {
        return await _categoryDal.GetByID(id);
    }

    public async Task TAdd(Category entity)
    {
        await _categoryDal.Insert(entity);
    }

    public async Task TDelete(Category entity) 
    {
        await _categoryDal.Delete(entity);
    }

    public async Task TUpdate(Category entity)
    {
        await _categoryDal.Update(entity);
    }
}

数据访问层 - CategoryRepository ：

public class CategoryRepository : GenericRepository<Category>, ICategoryDal
{
}

GenericRepository ：

public class GenericRepository<T> : IGenericDal<T> where T : class
{
    protected DatabaseContext dbContext;

    public GenericRepository(DatabaseContext context)
    {
        dbContext = context;
    }

    public async Task Delete(T t)
    {
        dbContext.Remove(t);
        await dbContext.SaveChangesAsync();
    }
     
    public IQueryable<T> FindByCondition(Expression<Func<T, bool>> expression)
    {
        return dbContext.Set<T>()
                        .Where(expression)
                        .AsNoTracking();
    }

    public async Task<T> GetByID(int id)
    {
        return await dbContext.Set<T>().FindAsync(id);
    }

    public async Task<List<T>> GetListAll()
    {
        return await dbContext.Set<T>().ToListAsync();
    }

    public async Task<List<T>> GetListAll(Expression<Func<T, bool>> filter)
    {
        return await dbContext.Set<T>()
                              .Where(filter)
                              .ToListAsync();
    }

    public async Task Insert(T t)
    {
        await dbContext.AddAsync(t);
        await dbContext.SaveChangesAsync();
    }

    public async Task Update(T t)
    {
        var updatedEntity = dbContext.Entry(t);
        updatedEntity.State = EntityState.Modified;
        dbContext.SaveChanges();
    }
}

UnitOfWork ：

public class UnitOfWorkRepository : IUnitOfWork
{
    private readonly DatabaseContext _dbContext;
    private IDbContextTransaction _transaction;
    private bool _disposed;

    public UnitOfWorkRepository(DatabaseContext dbContext)
    {
        _dbContext = dbContext;
    }

    public bool BeginNewTransaction()
    {
        try
        {
            _transaction = _dbContext.Database.BeginTransaction();
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this._disposed)
        {
            if (disposing)
            {
                _dbContext.Dispose();
            }
        }

        this._disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public IGenericDal<T> GetRepository<T>() where T : class
    {
        return new GenericRepository<T>(_dbContext);
    }

    public bool RollBackTransaction()
    {
        try
        {
            _transaction.Rollback();
            _transaction = null;
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }

    public int SaveChanges()
    {
        var transaction = _transaction != null ? _transaction : _dbContext.Database.BeginTransaction();

        using (transaction)
        {
            try
            {
                // Context boş ise hata fırlatıyoruz
                if (_dbContext == null)
                {
                    throw new ArgumentException("Context is null");
                }

                // SaveChanges metodundan dönen int result ı yakalayarak geri dönüyoruz.
                int result = _dbContext.SaveChanges();

                // Sorun yok ise kuyruktaki tüm işlemleri commit ederek bitiriyoruz.
                transaction.Commit();
                return result;
            }
            catch (Exception ex)
            {
                // Hata ile karşılaşılır ise işlemler geri alınıyor 
                transaction.Rollback();
                throw new Exception("Error on SaveChanges ", ex);
            }
        }
    }
}

IUnitOfWork ：

public interface IUnitOfWork : IDisposable
{
    bool BeginNewTransaction();
    bool RollBackTransaction();
    IGenericDal<T> GetRepository<T>() where T : class;
    int SaveChanges();
}

Answer 1

您可以检查链接中的来源。 https://www.linkedin.com/pulse/repository-unit-work-patterns.net-core-dimitar-iliev/