You need to cache data. Some data expires in 1 minute, some in 1 hour. How do you design this using OOP?

Question

Accepted Answer

I would hide the caching implementation behind an ICache abstraction and represent expiration as a cache policy rather than scattering TTL values throughout the application. Different consumers can provide different policies. The cache implementation can then enforce absolute or sliding expiration consistently. public record CachePolicy(TimeSpan Ttl);

public interface ICache
{
 T? Get(string key);
 void Set(string key, T value, CachePolicy policy);
}

public class ProductService
{
 private readonly ICache cache;

public ProductService(ICache cache)
 {
 this.cache = cache;
 }

public Product GetProduct(int id)
 {
 var key = $"product:{id}";
 var cached = cache.Get(key);
 if (cached != null) return cached;

var product = LoadProduct(id);
 cache.Set(key, product, new CachePolicy(TimeSpan.FromMinutes(1)));
 return product;
 }

private Product LoadProduct(int id) => new Product(id);
} Separate cache abstraction from cache implementation. Represent TTL and other behavior as explicit policies. Support absolute and, where appropriate, sliding expiration. Define cache invalidation rules and consistency expectations. For distributed applications, consider a distributed cache rather than process-local memory. Monitor hit rate, eviction rate, memory usage, and latency.

You need to cache data. Some data expires in 1 minute, some in 1 hour. How do you design this using OOP?

Policy-Based Cache Design

You need to cache data. Some data expires in 1 minute, some in 1 hour. How do you design this using OOP?

Policy-Based Cache Design

Scenario Questions

Follow-up Questions