Repository + Unit of Work z EF Core - czy to nadal potrzebne?
Tradycyjny wzorzec Repository
public interface IOrderRepository
{
Task<Order> GetByIdAsync(int id);
Task<List<Order>> GetAllAsync();
void Add(Order order);
void Remove(Order order);
}
public class OrderRepository : IOrderRepository
{
private readonly AppDbContext _context;
public OrderRepository(AppDbContext context) => _context = context;
public async Task<Order> GetByIdAsync(int id) => await _context.Orders.FindAsync(id);
public async Task<List<Order>> GetAllAsync() => await _context.Orders.ToListAsync();
public void Add(Order order) => _context.Orders.Add(order);
public void Remove(Order order) => _context.Orders.Remove(order);
}
Unit of Work - koordynacja transakcji między repozytoriami
public interface IUnitOfWork
{
IOrderRepository Orders { get; }
ICustomerRepository Customers { get; }
Task<int> SaveChangesAsync();
}
public class UnitOfWork : IUnitOfWork
{
private readonly AppDbContext _context;
public IOrderRepository Orders { get; }
public ICustomerRepository Customers { get; }
public UnitOfWork(AppDbContext context)
{
_context = context;
Orders = new OrderRepository(context);
Customers = new CustomerRepository(context);
}
public async Task<int> SaveChangesAsync() => await _context.SaveChangesAsync(); // JEDNA transakcja
}
// Użycie - obie zmiany zapisane ATOMOWO w jednej transakcji
await unitOfWork.Orders.AddAsync(order);
await unitOfWork.Customers.UpdateAsync(customer);
await unitOfWork.SaveChangesAsync(); // JEDNO wywołanie, JEDNA transakcja dla obu zmian
Kontrowersja - dlaczego wielu twierdzi, że to zbędne z EF Core
To jest częste pytanie dyskusyjne na rozmowach SE III - "czy warto owijać EF Core w Repository/UoW?" Argumenty przeciw:
1. DbContext JUŻ JEST Unit of Work
// DbContext SAM śledzi wszystkie zmiany i zapisuje je atomowo w JEDNEJ transakcji
_context.Orders.Add(order);
_context.Customers.Update(customer);
await _context.SaveChangesAsync(); // JEDNA transakcja, bez żadnego dodatkowego UnitOfWork
SaveChangesAsync() domyślnie owija wszystkie zmiany w jedną transakcję - dodatkowy IUnitOfWork duplikuje funkcjonalność, którą DbContext już ma wbudowaną.
2. DbSet<T> JUŻ JEST Repository
// DbSet ma już CRUD + LINQ - "repozytorium" tylko dodaje kolejną warstwę wołającą to samo
_context.Orders.Add(order);
_context.Orders.Remove(order);
await _context.Orders.Where(o => o.Status == "Pending").ToListAsync();
3. Utrata mocy LINQ/IQueryable - to jest najbardziej praktyczny argument, wracający do tego, o czym mówiliśmy przy IQueryable:
public interface IOrderRepository
{
Task<List<Order>> GetAllAsync(); // ❌ Zwraca WSZYSTKO, nie da się dodać filtra z zewnątrz jako IQueryable
}
// Serwis MUSI filtrować w pamięci, bo Repository już zmaterializował dane
var orders = await _repository.GetAllAsync();
var filtered = orders.Where(o => o.Status == "Pending"); // filtr W PAMIĘCI, nie w SQL!
Żeby to naprawić, repozytorium musiałoby zwracać IQueryable<Order>, ale to przecieka szczegóły EF Core przez interfejs repozytorium - co było głównym powodem, dla którego repozytorium miało istnieć (odizolowanie od konkretnej technologii dostępu do danych).
Kiedy Repository/UoW MA sens - argumenty ZA
1. Rzeczywista abstrakcja od EF Core (rzadka, ale realna potrzeba) - jeśli naprawdę planujesz podmienić EF Core na coś innego (Dapper, inne ORM), albo testujesz logikę biznesową bez żadnej bazy (mockując cały interfejs).
2. Enkapsulacja złożonych, powtarzalnych zapytań
public interface IOrderRepository
{
Task<List<Order>> GetOrdersWithPendingPaymentAsync(); // konkretna, nazwana operacja biznesowa
}
public class OrderRepository : IOrderRepository
{
public async Task<List<Order>> GetOrdersWithPendingPaymentAsync()
{
return await _context.Orders
.Include(o => o.Payments)
.Where(o => o.Status == "Pending" && o.Payments.All(p => p.Status != "Completed"))
.ToListAsync();
}
}
To jest specyficzny wzorzec repozytorium - nie generyczne CRUD, tylko nazwane metody odpowiadające konkretnym zapytaniom biznesowym, które enkapsulują złożoną logikę zapytania w jednym miejscu, reużywalną w wielu serwisach.
3. CQRS z MediatR - w tym wzorcu (o którym rozmawialiśmy) Handler często wywołuje DbContext bezpośrednio, bez żadnego repozytorium - to jest zresztą dominujący styl w nowoczesnych aplikacjach .NET.
Praktyczna rekomendacja - dominujący pogląd w środowisku .NET (2020s+)
Nie owijaj
DbContextw generyczne Repository/UoW "na wszelki wypadek" - to dodaje warstwę abstrakcji bez realnej korzyści, boDbContext/DbSetjuż są Unit of Work/Repository. Zamiast tego: albo wołajDbContextbezpośrednio z serwisu/Handlera CQRS, albo (jeśli chcesz enkapsulacji) twórz specyficzne metody repozytorium odpowiadające konkretnym zapytaniom biznesowym (jakGetOrdersWithPendingPaymentAsyncwyżej), zwracające już zmaterializowane dane, nie generycznyGetAll().
Tabela - kiedy co
| Podejście | Kiedy sensowne |
|---|---|
DbContext bezpośrednio w serwisie/Handlerze |
Domyślny wybór w większości nowoczesnych aplikacji .NET, zwłaszcza z CQRS |
| Specyficzne Repository (nazwane metody biznesowe) | Powtarzalne, złożone zapytania używane w wielu miejscach |
Generyczne IRepository<T>/IUnitOfWork |
Rzadko - głównie gdy realnie testujesz bez żadnej bazy/EF Core, albo firma ma to jako standard architektoniczny |