Что такое Generic Repository?

Что такое Generic Repository?

Generic Repository (обобщённый репозиторий) — это паттерн проектирования в архитектуре приложений, который предоставляет обобщённую (generic) реализацию Repository Pattern для работы с данными. Он позволяет создать единый, повторно используемый класс репозитория, способный обслуживать различные типы сущностей (например, User, Product, Order) без необходимости написания отдельного репозитория для каждого типа. Это достигается за счёт использования обобщённых типов (generics) в C#.

Основная цель и принцип работы

Цель Generic Repository — абстрагировать логику доступа к данным (например, запросы к базе данных) и обеспечить единообразный интерфейс для операций CRUD (Create, Read, Update, Delete). Вместо создания отдельных классов вроде UserRepository или ProductRepository, мы создаём один класс GenericRepository<T>, где T — это тип сущности (обычно класс модели или доменной сущности).

Пример базовой структуры Generic Repository в C#:

public interface IGenericRepository<T> where T : class
{
    Task<T> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task AddAsync(T entity);
    void Update(T entity);
    void Delete(T entity);
    Task<bool> SaveChangesAsync();
}

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly DbContext _context;
    private readonly DbSet<T> _dbSet;

    public GenericRepository(DbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
    }

    public async Task<T> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
    }

    public async Task<IEnumerable<T>> GetAllAsync()
    {
        return await _dbSet.ToListAsync();
    }

    public async Task AddAsync(T entity)
    {
        await _dbSet.AddAsync(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Update(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }

    public async Task<bool> SaveChangesAsync()
    {
        return await _context.SaveChangesAsync() > 0;
    }
}

Преимущества Generic Repository

• Уменьшение дублирования кода: Не нужно писать однотипные методы для каждой сущности. Например, операции GetById или Add будут работать для любого типа T.
• Упрощение поддержки: Изменения в логике доступа к данным (например, оптимизация запросов) можно внести в одном месте — в классе GenericRepository<T>.
• Гибкость и масштабируемость: Легко добавлять новые сущности без создания новых репозиториев. Достаточно использовать GenericRepository<NewEntity>.
• Согласованность интерфейса: Все репозитории следуют единому контракту (IGenericRepository<T>), что упрощает тестирование и внедрение зависимостей (Dependency Injection).
• Интеграция с ORM: Отлично сочетается с Entity Framework Core, так как DbSet<T> предоставляет готовые методы для работы с данными.

Недостатки и ограничения

• Ограниченная специфичность: Generic Repository может не покрывать сложные, специфичные для сущности запросы (например, фильтрация по нескольким полям или JOIN-операции). Для этого часто дополняется специфичными репозиториями (Specific Repositories) или шаблоном Specification.
• Риск "утечки абстракций": Если Generic Repository предоставляет прямой доступ к DbSet или IQueryable, это может привести к сложностям с производительностью (например, N+1 queries) и нарушению инкапсуляции.
• Избыточность в простых сценариях: Для небольших приложений с минимальной бизнес-логикой Generic Repository может добавить ненужную сложность.

Пример использования с Entity Framework Core

Допустим, у нас есть сущности User и Product. Вместо создания отдельных репозиториев, мы используем Generic Repository:

// Сущности
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Product
{
    public int Id { get; set; }
    public string Title { get; set; }
    public decimal Price { get; set; }
}

// Использование в сервисе
public class UserService
{
    private readonly IGenericRepository<User> _userRepository;

    public UserService(IGenericRepository<User> userRepository)
    {
        _userRepository = userRepository;
    }

    public async Task<User> GetUserById(int id)
    {
        return await _userRepository.GetByIdAsync(id);
    }
}

// Регистрация в DI-контейнере (например, в ASP.NET Core)
services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));

Расширение Generic Repository

На практике Generic Repository часто расширяют для поддержки сложных сценариев:

• Добавление пагинации: Метод GetPagedAsync(int page, int pageSize).
• Фильтрация через выражения: Метод FindAsync(Expression<Func<T, bool>> predicate).
• Поддержка спецификаций (Specification Pattern): Для инкапсуляции бизнес-правил запросов.

Пример с фильтрацией:

public interface IGenericRepository<T> where T : class
{
    // ... другие методы ...
    Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
}

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    // ... другие методы ...
    public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
    {
        return await _dbSet.Where(predicate).ToListAsync();
    }
}

Заключение

Generic Repository — это мощный инструмент для стандартизации доступа к данным в C#-приложениях, особенно при использовании ORM (Object-Relational Mapping) типа Entity Framework Core. Он способствует соблюдению принципов DRY (Don't Repeat Yourself) и SOLID (например, Single Responsibility). Однако важно балансировать его использование с потребностями проекта: для сложной бизнес-логики может потребоваться комбинация с другими паттернами (например, Unit of Work или Specification). В современных архитектурах (например, Clean Architecture или DDD) Generic Repository часто применяется как базовый слой, который дополняется более специализированными реализациями.