Repository Pattern & Unit of Work

By the end of this lesson you'll be able to hide your data-access details behind a clean repository, write a reusable generic IRepository<T>, coordinate several repositories with a Unit of Work, and swap a real database for a fake one so your business logic is trivially testable.

1. A Generic IRepository<T>

A generic repository works for any entity type — Book, Customer, Order — without you rewriting Add and GetById each time. The <T> is a type placeholder; the where T : IEntity constraint guarantees every T has an Id, which is the one thing the repository needs to look items up. Read this worked example — notice the List<T> storage is private, so callers go through the interface and never touch the shelf.

using System;
using System.Collections.Generic;
using System.Linq;

// Every entity this repository stores must expose an Id, so the
// repository can look items up by it. This is the ONLY thing the
// generic repository needs to know about T.
public interface IEntity
{
    int Id { get; set; }
}

// The contract: what a repository can DO, with no hint of HOW it does it.
// A service depends on THIS interface, never on a concrete class, so you
// can swap the storage (in-memory now, a database l
...

Your turn. The repository below is missing its two key lines. Fill in the two ___ blanks so Add stores the entity and GetById finds it, then run it.

using System;
using System.Collections.Generic;
using System.Linq;

public interface IEntity { int Id { get; set; } }

public interface IRepository<T> where T : IEntity
{
    void Add(T entity);
    T? GetById(int id);
}

// 🎯 YOUR TURN — implement the two methods of this in-memory repository.
public class InMemoryRepository<T> : IRepository<T> where T : IEntity
{
    private readonly List<T> _items = new();
    private int _nextId = 1;

    // 1) Add: give the entity the next Id, then store it
...

2. Using the Repository

Once the implementation exists, using it is the easy part — you call methods on the interface and forget about storage entirely. That's the whole point: the calling code reads like plain list operations. Here the repository is already built for you; you just drive it. Fill in the three ___ blanks to add two products, fetch one by Id, and count them.

using System;
using System.Collections.Generic;
using System.Linq;

public interface IEntity { int Id { get; set; } }

public interface IRepository<T> where T : IEntity
{
    void Add(T entity);
    T? GetById(int id);
    IEnumerable<T> GetAll();
}

public class InMemoryRepository<T> : IRepository<T> where T : IEntity
{
    private readonly List<T> _items = new();
    private int _nextId = 1;
    public void Add(T entity) { entity.Id = _nextId++; _items.Add(entity); }
    public T? GetById(int 
...

3. Keeping It Separate from EF Core

The in-memory repository was a teaching prop; a real app stores data in a database. The beautiful part is that the contract doesn't change — only the implementation does. Below, EfRepository<T> implements the same IRepository<T> using EF Core's DbSet<T>. Everything EF-specific — DbContext, ToListAsync, FindAsync — is sealed inside the class. The crucial detail: FindAsync returns IEnumerable<T>, not IQueryable<T>, so the query executes here and EF never leaks to the layers above.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;

// The SAME contract as before. The service layer depends on this and
// has no idea whether the data lives in a List or in SQL Server.
public interface IRepository<T> where T : class
{
    Task<T?> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
    Task AddAsync(T entity);
 
...

Because your service was written against IRepository<T>, you can switch from InMemoryRepository to EfRepository in your dependency-injection setup and the service never notices. That single fact is what justifies the pattern.

4. The Unit of Work

A Unit of Work coordinates several repositories so a group of changes is saved together — all or nothing. It holds one shared context and exposes the repositories as properties; calling SaveChanges() (or Commit()) once writes every pending change in a single transaction. This is what stops a half-finished operation — like reducing stock but failing to record the order — from leaving your data in a broken state. You'll build a small one yourself in the Mini-Challenge.

public class UnitOfWork : IUnitOfWork
{
    private readonly AppDbContext _context;
    public UnitOfWork(AppDbContext context) => _context = context;

    // BOTH repos share the one _context, so SaveChanges covers both.
    public IRepository<Customer> Customers => new EfRepository<Customer>(_context);
    public IRepository<Order> Orders       => new EfRepository<Order>(_context);

    public Task<int> SaveChangesAsync() => _context.SaveChangesAsync();
}

5. Testability — the Real Prize

Because your service depends on the interface IRepository<T>, a unit test can hand it a fake, in-memory implementation instead of a real database. No connection string, no migrations, no waiting — the test runs in milliseconds and is perfectly deterministic. This worked example tests an OrderService with a hand-written fake repository, no mocking library required.

using System;
using System.Collections.Generic;
using System.Linq;

// Because the service depends on IRepository<T> (an interface), a test can
// hand it a FAKE in-memory repository — no database, no network, instant.
public interface IRepository<T>
{
    T? GetById(int id);
    void Add(T entity);
}

public class Order { public int Id { get; set; } public decimal Total { get; set; } }

// The thing we want to test. It only knows the interface.
public class OrderService
{
    private readonly I
...

using System;
using System.Collections.Generic;
using System.Linq;

public interface IEntity { int Id { get; set; } }

public interface IRepository<T> where T : IEntity
{
    void Add(T entity);
    T? GetById(int id);
    IEnumerable<T> GetAll();
}

public class InMemoryRepository<T> : IRepository<T> where T : IEntity
{
    private readonly List<T> _items = new();
    private int _nextId = 1;
    public void Add(T entity) { entity.Id = _nextId++; _items.Add(entity); }
    public T? GetById(int 
...