C# : Cached Repository Pattern implementation

 

In modern software development, efficient data access is crucial for maintaining application performance. One way to improve data access performance is by implementing caching mechanisms. In this blog post, we'll explore how to implement the Cached Repository Pattern in C#, a design pattern that combines the benefits of a repository pattern with caching to optimize data access.

What is the Cached Repository Pattern? The Cached Repository Pattern is an architectural pattern that combines the Repository Pattern with caching mechanisms to improve data access performance. It provides a layer of abstraction over data access operations while transparently caching data retrieved from the underlying data source.

Step-by-Step Implementation:

Step 1: Define Repository Interface First, we define an interface that serves as the contract for interacting with the data source. This interface includes methods for common data access operations such as fetching all entities, fetching an entity by ID, adding, updating, and deleting entities.

public interface IDataRepository<T>
{
    IEnumerable<T> GetAll();
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(int id);
}

Step 2: Implement Concrete Repository Next, we implement a concrete repository class that fulfills the contract defined by the repository interface. This class interacts directly with the underlying data source, such as a database, to perform data access operations.

public class DataRepository<T> : IDataRepository<T>
{
    private readonly DbContext _dbContext;
    private readonly DbSet<T> _dbSet;

    public DataRepository(DbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = _dbContext.Set<T>();
    }

    public IEnumerable<T> GetAll()
    {
        return _dbSet.ToList();
    }

    public T GetById(int id)
    {
        return _dbSet.Find(id);
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
        _dbContext.SaveChanges();
    }

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

    public void Delete(int id)
    {
        var entity = GetById(id);
        if (entity != null)
        {
            _dbSet.Remove(entity);
            _dbContext.SaveChanges();
        }
    }
}

Step 3: Implement Cached Repository Now, we create a cached repository class that wraps the original repository. This cached repository adds caching functionality to the data access operations, transparently caching data retrieved from the underlying data source for improved performance.

public class CachedDataRepository<T> : IDataRepository<T>
{
    private readonly IDataRepository<T> _innerRepository;
    private IEnumerable<T> _cache;

    public CachedDataRepository(IDataRepository<T> innerRepository)
    {
        _innerRepository = innerRepository;
        RefreshCache();
    }

    public IEnumerable<T> GetAll()
    {
        return _cache;
    }

    public T GetById(int id)
    {
        return _cache.FirstOrDefault(item => GetId(item) == id);
    }

    public void Add(T entity)
    {
        _innerRepository.Add(entity);
        RefreshCache();
    }

    public void Update(T entity)
    {
        _innerRepository.Update(entity);
        RefreshCache();
    }

    public void Delete(int id)
    {
        _innerRepository.Delete(id);
        RefreshCache();
    }

    private void RefreshCache()
    {
        _cache = _innerRepository.GetAll();
    }

    private int GetId(T entity)
    {
        // Implement logic to get the ID of the entity
        // For example, if the entity is an object with an "Id" property:
        // return entity.Id;
    }
}

Step 4: Usage Finally, we demonstrate how to use the cached repository in our application to interact with the data source. We instantiate the repository with the appropriate dependencies and utilize its methods to fetch, add, update, and delete entities.

// Usage example
var dbContext = new YourDbContext();
var repository = new DataRepository<YourEntity>(dbContext);
var cachedRepository = new CachedDataRepository<YourEntity>(repository);

// Use the cached repository to fetch data
var data = cachedRepository.GetAll();

Conclusion: The Cached Repository Pattern is a powerful technique for optimizing data access performance in C# applications. By combining the benefits of the Repository Pattern with caching mechanisms, developers can achieve significant improvements in application responsiveness and efficiency. Consider employing this pattern in your next C# project to enhance data access performance and provide a better user experience.