.NET Repository Pattern

A guide for implementing the Repository pattern that abstracts the data access layer.

1. Project Structure

MyApp/
├── Program.cs
├── App.cs
├── Models/
│   └── User.cs
├── Repositories/
│   ├── IUserRepository.cs
│   └── UserRepository.cs
├── Services/
│   ├── IUserService.cs
│   └── UserService.cs
└── GlobalUsings.cs

2. Model Definition

namespace MyApp.Models;

public sealed record User(int Id, string Name, string Email);

3. Repository Layer

3.1 Interface

namespace MyApp.Repositories;

public interface IUserRepository
{
    Task<List<User>> GetAllAsync();
    Task<User?> GetByIdAsync(int id);
    Task AddAsync(User user);
    Task UpdateAsync(User user);
    Task DeleteAsync(int id);
}

3.2 Implementation

namespace MyApp.Repositories;

public sealed class UserRepository : IUserRepository
{
    private readonly List<User> _users = [];

    public Task<List<User>> GetAllAsync()
    {
        return Task.FromResult(_users.ToList());
    }

    public Task<User?> GetByIdAsync(int id)
    {
        return Task.FromResult(_users.FirstOrDefault(u => u.Id == id));
    }

    public Task AddAsync(User user)
    {
        _users.Add(user);
        return Task.CompletedTask;
    }

    public Task UpdateAsync(User user)
    {
        var index = _users.FindIndex(u => u.Id == user.Id);
        if (index >= 0) _users[index] = user;
        return Task.CompletedTask;
    }

    public Task DeleteAsync(int id)
    {
        _users.RemoveAll(u => u.Id == id);
        return Task.CompletedTask;
    }
}

4. Service Layer

4.1 Interface

namespace MyApp.Services;

public interface IUserService
{
    Task<IReadOnlyList<User>> GetAllUsersAsync();
    Task<User?> GetUserByIdAsync(int id);
}

4.2 Implementation

namespace MyApp.Services;

public sealed class UserService(IUserRepository repository) : IUserService
{
    private readonly IUserRepository _repository = repository;

    public async Task<IReadOnlyList<User>> GetAllUsersAsync()
    {
        var users = await _repository.GetAllAsync();
        return users.AsReadOnly();
    }

    public Task<User?> GetUserByIdAsync(int id)
    {
        return _repository.GetByIdAsync(id);
    }
}

5. DI Registration

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register Repository
        services.AddSingleton<IUserRepository, UserRepository>();

        // Register Service
        services.AddSingleton<IUserService, UserService>();

        services.AddSingleton<App>();
    })
    .Build();

6. Generic Repository (Optional)

public interface IRepository<T> where T : class
{
    Task<List<T>> GetAllAsync();
    Task<T?> GetByIdAsync(int id);
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}

7. Layer Structure

App (Presentation)
  ↓
Service Layer (Business Logic)
  ↓
Repository Layer (Data Access)
  ↓
Data Source (DB, API, File, etc.)

8. Core Principles

• Repository handles data access only
• Business logic goes in Service
• Abstract with interfaces for testability
• Use Constructor Injection for dependencies