C# / .NET Kompendium PLEN
.NET / C# / Entity Framework Core

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 DbContext w generyczne Repository/UoW "na wszelki wypadek" - to dodaje warstwę abstrakcji bez realnej korzyści, bo DbContext/DbSet już są Unit of Work/Repository. Zamiast tego: albo wołaj DbContext bezpośrednio z serwisu/Handlera CQRS, albo (jeśli chcesz enkapsulacji) twórz specyficzne metody repozytorium odpowiadające konkretnym zapytaniom biznesowym (jak GetOrdersWithPendingPaymentAsync wyżej), zwracające już zmaterializowane dane, nie generyczny GetAll().

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
Postaw mi kawę