Реализуем паттерн Unit of Work в ASP.NET Core

Привет, Хабр!

Сегодня разберём, как реализовать паттерн Unit of Work в ASP.NET Core. Вместо долгих теоретических рассуждений, посмотрим, зачем он вообще нужен, и как правильно его применить на практике.

Почему вообще нужен Unit of Work?

Ты наверняка сталкивался с ситуацией, когда несколько операций с базой данных нужно обернуть в одну транзакцию. Например, при создании пользователя нужно добавить его в несколько таблиц. А что если что‑то пошло не так? Одна из операций упала, а данные уже частично добавлены? Здесь и помогает Unit of Work. Он следит за тем, чтобы все изменения проходили через одну точку, и либо подтверждаются все сразу, либо откатываются.

Но почему именно Unit of Work, а не просто транзакции через DbContext? Ответ простой — паттерн позволяет работать с несколькими репозиториями одновременно.

Интерфейс IUnitOfWork

Начнём с основы — интерфейса IUnitOfWork, который будет управлять нашими транзакциями.

public interface IUnitOfWork : IDisposable {     IRepository UserRepository { get; }     IRepository OrderRepository { get; }          void Commit();     void Rollback(); } 

Пара заметок:

• IDisposable нужен для корректного освобождения ресурсов. Это значит, что когда ты закончишь работу с транзакцией, Dispose автоматически закроет все соединения и освободит память. Не забываем вызывать метод!

• Commit и Rollback — это методы, которые отвечают за подтверждение или откат транзакций.

Теперь у нас есть интерфейс, переходим к главному — DbContext.

Основа операции — DbContext

Как я уже говорил, Unit of Work сам по себе мало что может, если у него нет связи с базой данных. Здесь на помощь приходит DbContext, который отвечает за все операции с БД в ASP.NET Core.

public class AppDbContext : DbContext {     public DbSet Users { get; set; }     public DbSet Orders { get; set; }      public AppDbContext(DbContextOptions options)         : base(options) { }          public void BeginTransaction()     {         Database.BeginTransaction();     }      public void CommitTransaction()     {         Database.CommitTransaction();     }      public void RollbackTransaction()     {         Database.RollbackTransaction();     } }

Тут видим несколько методов:

• BeginTransaction — начинает транзакцию. Это первый шаг, перед тем как выполнять изменения.

• CommitTransaction — подтверждает все изменения.

• RollbackTransaction — откатывает изменения, если что-то пошло не так.

Эти методы — основа работы паттерна Unit of Work, но ещё важнее то, как их правильно интегрировать в бизнес-логику.

Реализация Unit of Work

Теперь соберём наш Unit of Work в единый механизм.

public class UnitOfWork : IUnitOfWork {     private readonly AppDbContext _context;     private IRepository _userRepository;     private IRepository _orderRepository;      public UnitOfWork(AppDbContext context)     {         _context = context;     }      public IRepository UserRepository     {         get { return _userRepository ??= new Repository(_context); }     }      public IRepository OrderRepository     {         get { return _orderRepository ??= new Repository(_context); }     }      public void Commit()     {         _context.SaveChanges();         _context.CommitTransaction();     }      public void Rollback()     {         _context.RollbackTransaction();     }      public void Dispose()     {         _context.Dispose();     } 

Обрати внимание:

• Ленивая инициализация репозиториев. Это значит, что мы создаём репозитории только тогда, когда они действительно нужны.

• Commit вызывает метод SaveChanges, который сохраняет все изменения в базу, а затем подтверждает транзакцию. В случае ошибки — откат.

Когда Unit of Work — это не лучший выбор?

Unit of Work — отличный инструмент для управления транзакциями, но его не всегда стоит использовать. Например, если есть приложение с небольшими и простыми операциями, добавление лишнего уровня абстракции только усложнит код. В таких случаях лучше использовать дефолт транзакции через DbContext.

Помимо этого, если существует слишком много репозиториев и зависимостей, Unit of Work может стать лишь узким местом по производительности. Поэтому всегда оценивай, насколько оправдано его использование.

Репозитории

Unit of Work без репозиториев — как велосипед без колёс. Они управляют конкретными сущностями и отвечают за CRUD-операции. Пример репозитория:

public class Repository : IRepository where T : class {     private readonly AppDbContext _context;     private readonly DbSet _dbSet;      public Repository(AppDbContext context)     {         _context = context;         _dbSet = context.Set();     }      public void Add(T entity)     {         _dbSet.Add(entity);     }      public void Update(T entity)     {         _dbSet.Update(entity);     }      public void Delete(T entity)     {         _dbSet.Remove(entity);     }      public IEnumerable GetAll()     {         return _dbSet.ToList();     }      public T GetById(int id)     {         return _dbSet.Find(id);     } }

Этот репозиторий универсален и может работать с любыми сущностями. Все операции — через DbSet.

Как это выглядит на практике

Теперь посмотрим на реальный пример использования Unit of Work в контроллере:

public class UserController : Controller {     private readonly IUnitOfWork _unitOfWork;      public UserController(IUnitOfWork unitOfWork)     {         _unitOfWork = unitOfWork;     }      [HttpPost]     public IActionResult CreateUser(UserViewModel model)     {         try         {             _unitOfWork.UserRepository.Add(new User { Name = model.Name });             _unitOfWork.Commit();             return Ok("User created successfully.");         }         catch (Exception ex)         {             _unitOfWork.Rollback();             return BadRequest($"Error: {ex.Message}");         }     } }

Мы добавляем пользователя через UserRepository и фиксируем транзакцию через Commit. Если что-то пошло не так, транзакция откатывается.

Как это тестировать?

Тестирование транзакций — важная часть работы с Unit of Work. Для этого идеально подходит библиотека Moq:

[Test] public void CreateUser_ShouldCommitTransaction_WhenUserIsValid() {     var mockUnitOfWork = new Mock();     var controller = new UserController(mockUnitOfWork.Object);      var result = controller.CreateUser(new UserViewModel { Name = "Test User" });      mockUnitOfWork.Verify(u => u.Commit(), Times.Once); }

Здесь проверяем, что метод Commit вызывается при успешном добавлении пользователя.

Заключение

Теперь ты знаешь, как реализовать и использовать паттерн Unit of Work в ASP.NET Core. Но помни: не всегда этот паттерн нужен, и его использование должно быть оправдано архитектурой проекта. Если у тебя возникли вопросы или есть чем поделиться — пиши в комментариях.

Пользуясь случаем, напоминаю про открытые уроки, которые скоро пройдут в рамках курса «C# ASP.NET Core разработчик»:

• 16 октября: .NET Aspire: очередная прорывная технология в мире dotnet или не очень? Запись по ссылке

• 24 октября: Деплой ASP.NET приложений в Kubernetes. Запись по ссылке