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

Question

There are many examples on the inte.net about the use of unit of work and generic repository together, but I couldn't find exactly how to apply the unit of work repository pattern to my own project. Because everyone did it differently.

Actually, I set up the unit of work structure, but I don't quite understand how I can use it in my own project? How can I apply the unit of work repository I made to my own project? Can you help me with this? Can you tell me if I have a mistake? This is how I saw the unit of work repository on the inte.net and implemented it.

First of all, if I just talk about my project, my project is an ASP.NET Core Web API project and basically a 3-layer structure:

1. API layer. I have controllers in the API layer.
2. Second is the business layer. The business layer only serves to communicate with the data access layer.
3. The third layer is the data access layer, in this layer I do the database operations, such as adding, deleting, updating.

I'm doing these with the generic repository. As an example, I am sharing some of my code below.

I just shared category as an example, but I have more than one class like category.

API layer - 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);
    }
}

Business layer - 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);
    }
}

Data Access layer - 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

You can check the source in the link. https://www.linkedin.com/pulse/repository-unit-work-patterns.net-core-dimitar-iliev/