HybridCache: Alternative(RemoveByTagAsync) Cache Invalidation Pattern Implementation

[Darka7]

HybridCache: Alternative Cache Invalidation Pattern Implementation

Problem Description

HybridCache's built-in tag-based cache removal was not functioning as expected, requiring an alternative approach for managing cache invalidation across services and operations.

Solution Overview

Implemented a custom two-layer caching system that provides better control over cache invalidation and maintains consistency across related operations.

Implementation

1. Base Cache Layer (NvCacheHybrid)

using Microsoft.Extensions.Caching.Hybrid;
using System.Collections.Concurrent;

public interface INvCacheHybrid
{
    ValueTask<T> GetOrCreateAsync<T>(string GroupKey, Func<Task<T>> factory, dynamic?[] deps);
    ValueTask<T> GetOrCreateAsync<T>(string GroupKey, Func<Task<T>> factory, dynamic?[] deps, TimeSpan duration);
    Task Remove(string key);
    Task Remove(string[] keys);
    Task RemoveAll();
}

public class NvCacheHybrid : INvCacheHybrid
{
    private readonly HybridCache cache;
    private ConcurrentDictionary<string, ConcurrentBag<string>> KeysCache =
        new ConcurrentDictionary<string, ConcurrentBag<string>>();

    public NvCacheHybrid(HybridCache cache)
    {
        this.cache = cache;
    }

    private string GetKeys(string mainKey, dynamic?[] keys)
    {
        var getkey = string.Join("_", keys.Select(item => $"{item ?? "_null_"}"));
        var keyList = KeysCache.GetOrAdd(mainKey, _ => new ConcurrentBag<string>());
        keyList.Add(getkey);
        KeysCache.GetOrAdd("AppKeyCache", _ => new ConcurrentBag<string>()).Add(getkey);
        return getkey;
    }

    public async ValueTask<T> GetOrCreateAsync<T>(string GroupKey, Func<Task<T>> factory, dynamic?[] deps)
    {
        return await cache.GetOrCreateAsync<T>(GetKeys(GroupKey, deps), async Task => await factory());
    }

    public async ValueTask<T> GetOrCreateAsync<T>(string GroupKey, Func<Task<T>> factory, dynamic?[] deps, TimeSpan duration)
    {
        var options = new HybridCacheEntryOptions()
        {
            Expiration = duration,
            LocalCacheExpiration = duration
        };
        return await cache.GetOrCreateAsync<T>(GetKeys(GroupKey, deps), async Task => await factory(), options: options);
    }

    public async Task Remove(string[] keys)
    {
        var keysToRemove = keys
            .Where(predicate: KeysCache.ContainsKey)
            .SelectMany(key => KeysCache[key])
            .Distinct();
        await cache.RemoveAsync(keysToRemove);
    }

    public async Task Remove(string key)
    {
        if (KeysCache.TryGetValue(key, out var cacheKeys))
        {
            await cache.RemoveAsync(cacheKeys);
        }
    }

    public async Task RemoveAll()
    {
        if (KeysCache.TryGetValue("AppKeyCache", out var allKeys))
        {
            await cache.RemoveAsync(allKeys);
        }
    }
}

### 2. Service Cache Layer (ICacheHybrid<TClass>)

```csharp
public interface ICacheHybrid<out TClass> 
{
    ValueTask<T> GetOrCreateAsync<T>(Func<Task<T>> factory, dynamic?[] deps);
    ValueTask<T> GetOrCreateAsync<T>(Func<Task<T>> factory, dynamic?[] deps, TimeSpan duration);
    Task RemoveCache();
    Task RemoveCache(CacheKey key);
    Task RemoveCache(CacheKey[] keys);
    Task RemoveCacheAll();
}

public class NvServiceCache<TClass> : ICacheHybrid<TClass>
{
    private readonly INvCacheHybrid cache;
    private readonly string MainKey;

    public NvServiceCache(INvCacheHybrid cache)
    {
        this.cache = cache;
        this.MainKey = typeof(TClass).Name;
    }

    public async ValueTask<T> GetOrCreateAsync<T>(Func<Task<T>> factory, dynamic?[] deps)
    {
        return await cache.GetOrCreateAsync(MainKey, factory, deps);
    }

    public async ValueTask<T> GetOrCreateAsync<T>(Func<Task<T>> factory, dynamic?[] deps, TimeSpan duration)
    {
        return await cache.GetOrCreateAsync<T>(MainKey, factory, deps, duration);
    }

    public async Task RemoveCache()
    {
        await cache.Remove(MainKey);
    }

    public async Task RemoveCache(CacheKey key)
    {
        await cache.Remove(key.ToString());
    }

    public async Task RemoveCache(CacheKey[] keys)
    {
        var getkeys = keys.Select(x => x.ToString());
        await cache.Remove(getkeys.ToArray());
    }

    public async Task RemoveCacheAll()
    {
        await cache.RemoveAll();
    }
}

### 3. Example Implementation (LevantamientoActivosByUbicacionService)

```csharp
public class LevantamientoActivosByUbicacionService : ILevantamientoActivosByUbicacionService
{
    private readonly ISqlDataAccess sql;
    private readonly ICacheHybrid<LevantamientoActivosByUbicacionService> cache;

    public LevantamientoActivosByUbicacionService(
        ISqlDataAccess sql,
        ICacheHybrid<LevantamientoActivosByUbicacionService> cache)
    {
        this.sql = sql;
        this.cache = cache;
    }

    public async Task<IEnumerable<LevantamientoActivosTpDto>> ActivosObtenerByUbicacionParaInforme(int IdUbicacionActivo)
    => await cache.GetOrCreateAsync(
            () => sql.QueryAsync<LevantamientoActivosTpDto>("cont.ActivosObtenerByUbicacionParaInforme"),
            [nameof(ActivosObtenerByUbicacionParaInforme), IdUbicacionActivo]
        );

    public async Task<DBEntity> LevantamientoActivoActualizarUbicacion(LevantamientoActivosTpDto entity, string UsuarioModifica)
    {
        var result = await sql.ExecuteAsync("cont.LevantamientoActivoActualizarUbicacion", new
        {
            entity.IdActivoFijos,
            entity.IdUbicacionActivo,
            UsuarioModifica
        });
        await cache.RemoveCache();
        await cache.RemoveCache([CacheKey.ActivoFijosService]);

        return result;
    }

    // Otros métodos del servicio...
}

4. Dependency Injection Setup

public void ConfigureServices(IServiceCollection services)
{
    services.AddHybridCache();
    services.AddSingleton<INvCacheHybrid, NvCacheHybrid>();
    services.AddScoped(typeof(ICacheHybrid<>), typeof(NvServiceCache<>));
}

Key Features

1. Thread-safe Key Management:

   • Uses ConcurrentDictionary and ConcurrentBag for thread-safe operations
   • Prevents race conditions during cache key management

2. Hierarchical Cache Control:

   • Service-level cache invalidation
   • Operation-specific cache entries
   • Cross-service cache coordination

3. Flexible Cache Duration:

   • Support for custom cache durations
   • Default and timed cache entries

4. Automatic Key Tracking:

   • Maintains registry of all cache keys
   • Supports bulk cache invalidation
   • Prevents memory leaks

Usage Notes

1. Cache Key Generation:

   • Keys are automatically generated using service name + operation name + parameters
   • Null parameters are handled with "null" placeholder

2. Cache Invalidation:

   • Use RemoveCache() for service-specific cache clear
   • Use RemoveCache(CacheKey[]) for related services
   • Use RemoveCacheAll() for full cache clear

3. Performance Considerations:

   • Key tracking adds minimal overhead
   • Thread-safe collections ensure concurrent access
   • Bulk operations are optimized

Migration Notes

When migrating from tag-based caching:

1. Replace tag decorators with appropriate cache key arrays
2. Update cache invalidation calls to use new RemoveCache methods
3. Consider service dependencies for cache invalidation

Remember to maintain the CacheKey enum with all service identifiers for cross-service cache invalidation.