Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

Home Interviews What is lazy loading in caching, and when should it be used? – MindStick
Ask Question

1 Answers

ICSM Computer
ICSM Computer 10 Mar 2025
Report Abuse

Lazy Loading in Caching (Cache-Aside Pattern)

Lazy Loading, also known as Cache-Aside, is a caching strategy where data is loaded into the cache only when it is requested. If the requested data is not found in the cache (cache miss), the application fetches it from the database, stores it in the cache, and returns it to the user.

How Lazy Loading Works

  1. Check Cache: The application first checks if the data exists in Redis.
  2. Cache Miss: If the data is not found, it fetches it from the database.
  3. Cache Update: The fetched data is stored in Redis with an optional expiration time (TTL).
  4. Return Data: The data is returned to the user.
  5. Subsequent Requests: Future requests will retrieve data from the cache instead of querying the database.

Example in C# using Redis

using StackExchange.Redis;
using System;

public class RedisCacheService
{
    private readonly IDatabase _cache;
    private readonly TimeSpan _cacheExpiry = TimeSpan.FromMinutes(10);

    public RedisCacheService()
    {
        var redis = ConnectionMultiplexer.Connect("localhost");
        _cache = redis.GetDatabase();
    }

    public string GetData(string key)
    {
        string cachedData = _cache.StringGet(key);

        if (!string.IsNullOrEmpty(cachedData))
        {
            Console.WriteLine("Cache Hit");
            return cachedData;
        }

        Console.WriteLine("Cache Miss - Fetching from DB...");
        string dataFromDb = FetchFromDatabase(key); // Simulate DB call

        _cache.StringSet(key, dataFromDb, _cacheExpiry); // Store in cache

        return dataFromDb;
    }

    private string FetchFromDatabase(string key)
    {
        return $"Database Value for {key}"; // Simulated DB fetch
    }
}

// Usage
var cacheService = new RedisCacheService();
string result = cacheService.GetData("user:123");
Console.WriteLine(result);

When to Use Lazy Loading?

Use When:

  • Data doesn’t change frequently.
  • The cache size should be optimized (only requested data is stored).
  • Stale data is acceptable for a short period.
  • Read-heavy applications where frequent cache hits improve performance.

Avoid When:

  • Real-time updates are required (use write-through instead).
  • High cache misses would cause initial latency (use preloading or refresh-ahead strategies).
  • The database cannot handle frequent cache misses efficiently.
MindStick Training
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md