How do you implement caching in cloud .NET apps?

Question

ICSM · Answer

Why caching matters in cloud apps

Cloud apps often talk to databases, APIs, and storage services that are:

Remote
Metered (you pay per call)
Slower than memory

Caching stores frequently used data closer to the app so repeated requests don’t hit those expensive resources.

Common caching layers in .NET cloud apps

1. In-Memory Cache (Local Cache)

Best for single instance or non-critical shared data.

In .NET, this is usually:

IMemoryCache

Use cases

Configuration data
Read-heavy, low-volatility data
Temporary computations

Pros

Extremely fast
Simple to implement

Cons

Not shared across instances
Cache is lost on app restart or scale-out

Example

services.AddMemoryCache();

public class ProductService
{
    private readonly IMemoryCache _cache;

    public ProductService(IMemoryCache cache)
    {
        _cache = cache;
    }

    public Product GetProduct(int id)
    {
        return _cache.GetOrCreate($"product_{id}", entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5);
            return LoadProductFromDatabase(id);
        });
    }
}

2. Distributed Cache (Recommended for cloud)

Used when your app runs on multiple instances.

Common options:

Azure Cache for Redis
AWS ElastiCache
Redis (self-hosted or managed)

In .NET:

IDistributedCache
StackExchange.Redis

Use cases

User sessions
Shared reference data
API responses
Rate limiting

Pros

Shared across all app instances
Survives app restarts
Scales independently

Cons

Network call (slower than in-memory)
Needs serialization

Example

services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "your-redis-endpoint";
    options.InstanceName = "SampleApp:";
});

public async Task<string> GetDataAsync(string key)
{
    var cached = await _cache.GetStringAsync(key);
    if (cached != null)
        return cached;

    var data = GetFromApi();
    await _cache.SetStringAsync(
        key,
        data,
        new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
        });

    return data;
}

3. Hybrid Caching (Best of both worlds)

A two-level cache:

In-memory cache (L1)
Distributed cache (L2 – Redis)

Flow

Check memory → fastest
If missing, check Redis
If missing, load from DB and store in both
This pattern is common in high-traffic production systems.

Caching at API level (Response Caching)

For REST APIs, you can cache HTTP responses.

services.AddResponseCaching();

app.UseResponseCaching();

[ResponseCache(Duration = 60)]
public IActionResult Get()
{
    return Ok(GetData());
}

This reduces load before your controller logic even runs.

Cloud best practices

Always set TTL (expiration)
Use cache-aside pattern (app controls cache)
Monitor cache hit/miss ratio
Add fallbacks if cache is unavailable
Don’t treat cache as a database

Typical real-world setup

In production cloud apps:

IMemoryCache → ultra-fast local cache
Redis → shared distributed cache
Response caching / CDN → edge caching for public APIs

interview

How do you implement caching in cloud .NET apps?

ICSM

Can you answer this question?

1 Answers

Why caching matters in cloud apps

Common caching layers in .NET cloud apps

1. In-Memory Cache (Local Cache)

2. Distributed Cache (Recommended for cloud)

3. Hybrid Caching (Best of both worlds)

Caching at API level (Response Caching)

Cloud best practices

Typical real-world setup

Liked By