Repository Pattern

TL;DR

Mediate between the domain and the data-access layer — expose persistence as an in-memory-like collection behind an interface, so the domain never depends on EF Core, SQL, or the ORM.

How it works

🧩 Example — The domain owns the interface, infrastructure provides the implementation

// Domain / application layer — the contract lives WITH the domain (Dependency Inversion)
public interface IOrderRepository
{
    Task<Order?> GetByIdAsync(Guid id);
    Task<IReadOnlyList<Order>> GetPendingAsync();
    Task AddAsync(Order order);
    void Remove(Order order);
}

// Infrastructure layer — EF Core implementation, swappable for Dapper / Mongo / a fake
public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _db;
    public OrderRepository(AppDbContext db) => _db = db;

    public Task<Order?> GetByIdAsync(Guid id) =>
        _db.Orders.FirstOrDefaultAsync(o => o.Id == id);

    public async Task<IReadOnlyList<Order>> GetPendingAsync() =>
        await _db.Orders.Where(o => o.Status == OrderStatus.Pending).ToListAsync();

    public async Task AddAsync(Order order) => await _db.Orders.AddAsync(order);

    public void Remove(Order order) => _db.Orders.Remove(order);
}

// --- Usage (application service) ---
public class CancelOrderHandler
{
    private readonly IOrderRepository _orders;
    private readonly IUnitOfWork _uow;

    public CancelOrderHandler(IOrderRepository orders, IUnitOfWork uow)
    {
        _orders = orders;
        _uow = uow;
    }

    public async Task Handle(Guid orderId)
    {
        var order = await _orders.GetByIdAsync(orderId)
                    ?? throw new NotFoundException(orderId);
        order.Cancel();                 // domain behaviour
        await _uow.SaveChangesAsync();  // Unit of Work commits the transaction
    }
}

✅ Why it matters:

• The domain/application code depends on IOrderRepository, not EF Core — you can swap Dapper, Mongo, or an in-memory fake without touching business logic.
• Centralises query logic (GetPendingAsync) so it isn't copy-pasted across controllers and services.
• Makes the domain trivially unit-testable with an in-memory fake repository — no database, no mocking framework.
• Pairs with Unit of Work to commit many changes across aggregates in one transaction.

Quick recall Q&A