Redis Caching Implementation

# Download from: https://github.com/microsoftarchive/redis/releases
# Extract and run redis-server.exe

# Or use Docker:
docker run -d -p 6379:6379 --name redis redis:latest

# Install Redis
sudo apt-get update
sudo apt-get install redis-server

# Start Redis
sudo systemctl start redis
sudo systemctl enable redis

# Or use Docker:
docker run -d -p 6379:6379 --name redis redis:latest

{
  "Redis": {
    "Configuration": "localhost:6379",
    "InstanceName": "ShirinzadShop:"
  },
  "AbpDistributedCache": {
    "GlobalCacheEntryOptions": {
      "SlidingExpiration": "00:30:00"
    }
  }
}

{
  "Redis": {
    "Configuration": "your-redis-server:6379,password=YourPassword,ssl=True,abortConnect=False",
    "InstanceName": "ShirinzadShop:Prod:"
  }
}

public override void ConfigureServices(ServiceConfigurationContext context)
{
    var configuration = context.Services.GetConfiguration();

    // Configure Redis distributed cache
    context.Services.AddStackExchangeRedisCache(options =>
    {
        options.Configuration = configuration["Redis:Configuration"];
        options.InstanceName = configuration["Redis:InstanceName"];
    });
}

public class ProductAppService
{
    private readonly CacheService _cacheService;

    public async Task<ProductDto> GetAsync(Guid id)
    {
        var cacheKey = CacheKeys.GetProductDetailsKey(id);

        return await _cacheService.GetOrCreateAsync(
            cacheKey,
            async () => await LoadProductFromDatabaseAsync(id),
            TimeSpan.FromHours(2)
        );
    }
}

public async Task<List<Product>> GetFeaturedProductsAsync()
{
    var cached = await _cacheService.GetAsync<List<Product>>(
        CacheKeys.FeaturedProductsKey
    );

    if (cached != null)
    {
        return cached;
    }

    var products = await _productRepository.GetListAsync(
        p => p.IsFeatured && p.IsActive
    );

    await _cacheService.SetAsync(
        CacheKeys.FeaturedProductsKey,
        products,
        TimeSpan.FromHours(1)
    );

    return products;
}

public class ProductAppService
{
    private readonly CacheInvalidationService _cacheInvalidation;

    public async Task<ProductDto> UpdateAsync(Guid id, UpdateProductDto input)
    {
        var product = await _productRepository.GetAsync(id);

        // Update product...
        await _productRepository.UpdateAsync(product);

        // Invalidate all related caches
        await _cacheInvalidation.InvalidateProductCacheAsync(id);

        return ObjectMapper.Map<Product, ProductDto>(product);
    }
}

public class CacheInvalidationService
{
    private readonly IDistributedCache _cache;

    public async Task InvalidateProductCacheAsync(Guid productId)
    {
        // Remove specific product caches
        await _cache.RemoveAsync($"product:{productId}");
        await _cache.RemoveAsync($"product:details:{productId}");

        // Remove list caches that might contain this product
        await _cache.RemoveAsync("product:featured");
        await _cache.RemoveAsync("product:low-stock");

        // Remove category and brand caches if needed
        // Implementation depends on business logic
    }

    public async Task InvalidateCategoryCacheAsync(Guid categoryId)
    {
        await _cache.RemoveAsync($"category:{categoryId}");
        await _cache.RemoveAsync("category:tree");
        await _cache.RemoveAsync("category:list");
    }

    public async Task InvalidateDashboardCacheAsync()
    {
        await _cache.RemoveAsync("dashboard:statistics");
        await _cache.RemoveAsync("dashboard:recent-orders");
    }
}

public class YourApplicationModule : AbpModule
{
    public override async Task OnApplicationInitializationAsync(
        ApplicationInitializationContext context)
    {
        var cacheWarming = context.ServiceProvider
            .GetRequiredService<CacheWarmingService>();

        // Warm all critical caches
        await cacheWarming.WarmAllCachesAsync();
    }
}

public class CacheWarmingService
{
    private readonly CacheService _cacheService;
    private readonly IProductRepository _productRepository;
    private readonly ICategoryRepository _categoryRepository;

    public async Task WarmAllCachesAsync()
    {
        await WarmProductCachesAsync();
        await WarmCategoryCachesAsync();
        await WarmConfigurationCachesAsync();
    }

    private async Task WarmProductCachesAsync()
    {
        // Featured products
        var featuredProducts = await _productRepository.GetListAsync(
            p => p.IsFeatured && p.IsActive,
            maxResultCount: 10
        );
        await _cacheService.SetAsync(
            "product:featured",
            featuredProducts,
            TimeSpan.FromHours(1)
        );

        // Top selling products
        var topSelling = await GetTopSellingProductsAsync();
        await _cacheService.SetAsync(
            "product:top-selling",
            topSelling,
            TimeSpan.FromHours(1)
        );
    }

    private async Task WarmCategoryCachesAsync()
    {
        // Category tree
        var categoryTree = await BuildCategoryTreeAsync();
        await _cacheService.SetAsync(
            "category:tree",
            categoryTree,
            TimeSpan.FromHours(6)
        );
    }

    private async Task WarmConfigurationCachesAsync()
    {
        // Site settings, payment methods, shipping methods, etc.
    }
}

public class CacheWarmingJob : IAsyncBackgroundJob<CacheWarmingArgs>
{
    public async Task ExecuteAsync(CacheWarmingArgs args)
    {
        await _cacheWarmingService.WarmAllCachesAsync();
    }
}

// Schedule: Run every 6 hours
await _backgroundJobManager.EnqueueAsync(
    new CacheWarmingArgs { WarmProducts = true },
    BackgroundJobPriority.Low,
    TimeSpan.FromHours(6)
);

public async Task<DashboardStatisticsDto> GetDashboardStatisticsAsync()
{
    // Try cache first
    var cached = await _cacheService.GetAsync<DashboardStatisticsDto>(
        CacheKeys.DashboardStatsKey
    );

    if (cached != null)
    {
        return cached;
    }

    // Cache miss - load from database
    var stats = await CalculateDashboardStatisticsAsync();

    // Store in cache for next request
    await _cacheService.SetAsync(
        CacheKeys.DashboardStatsKey,
        stats,
        TimeSpan.FromMinutes(5)
    );

    return stats;
}

# Connect to Redis
redis-cli

# List all keys
KEYS *

# List keys with pattern
KEYS product:*

# Get key value
GET product:details:guid-here

# Get key TTL
TTL product:details:guid-here

# Delete key
DEL product:details:guid-here

# Flush all cache (DANGER!)
FLUSHALL

# Get cache statistics
INFO stats

# Monitor commands in real-time
MONITOR

public class CacheMonitoringService
{
    private int _hits = 0;
    private int _misses = 0;

    public async Task<T?> GetWithMonitoringAsync<T>(string key)
        where T : class
    {
        var result = await _cacheService.GetAsync<T>(key);

        if (result != null)
            Interlocked.Increment(ref _hits);
        else
            Interlocked.Increment(ref _misses);

        return result;
    }

    public double GetHitRate()
    {
        var total = _hits + _misses;
        return total == 0 ? 0 : (double)_hits / total * 100;
    }

    public CacheStatistics GetStatistics()
    {
        return new CacheStatistics
        {
            Hits = _hits,
            Misses = _misses,
            HitRate = GetHitRate()
        };
    }
}

redis-cli INFO memory

# Set maximum memory
CONFIG SET maxmemory 2gb

# Set eviction policy (allkeys-lru recommended)
CONFIG SET maxmemory-policy allkeys-lru

# Check memory usage
redis-cli INFO memory

# Set max memory policy
CONFIG SET maxmemory 2gb
CONFIG SET maxmemory-policy allkeys-lru

"Redis": {
    "Configuration": "localhost:6379,connectTimeout=5000,syncTimeout=1000,abortConnect=false"
}

{
  "Redis": {
    "Configuration": "node1:6379,node2:6379,node3:6379",
    "InstanceName": "ShirinzadShop:"
  }
}

{
  "Redis": {
    "Configuration": "sentinel1:26379,sentinel2:26379,sentinel3:26379,serviceName=mymaster",
    "InstanceName": "ShirinzadShop:"
  }
}