Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions 1.2.0

Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions

Una biblioteca de abstracciones para implementar sistemas de caché híbrido en aplicaciones .NET. Define interfaces para almacenar y recuperar datos en caché con métodos tipados, control de invalidación y soporte para claves compuestas.

Instalación

Package Manager

Install-Package Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions

.NET CLI

dotnet add package Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions

PackageReference

<PackageReference Include="Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions" Version="1.1.0" />

Características principales

• Abstracciones para caché híbrido: Define interfaces para implementar estrategias de caché combinadas
• Métodos tipados: Soporte para operaciones de caché con tipo genérico
• Control granular de la invalidación: Métodos para eliminar entradas específicas o toda la caché
• Soporte para claves compuestas: Permite crear claves de caché basadas en múltiples parámetros
• Integración sencilla: Diseñado para funcionar con inyección de dependencias en .NET
• Mejora de testabilidad: Facilita la creación de mocks para pruebas unitarias

Interfaces principales

La biblioteca define las siguientes interfaces:

INvCacheHybrid

Interfaz base para el manejo de caché híbrido:

public interface INvCacheHybrid
{
    // Obtiene o crea un valor en caché con claves específicas
    ValueTask<T> GetOrCreateAsync<T>(
        string GroupKey, 
        Func<Task<T>> factory, 
        dynamic?[] deps);
    
    // Obtiene o crea un valor en caché con duración personalizada
    ValueTask<T> GetOrCreateAsync<T>(
        string GroupKey, 
        Func<Task<T>> factory, 
        dynamic?[] deps, 
        TimeSpan duration);
    
    // Elimina entradas por clave específica
    Task Remove(string key);
    
    // Elimina entradas por conjunto de claves
    Task Remove(string[] keys);
    
    // Elimina todas las entradas de caché
    Task RemoveAll();
}

### ICacheHybrid&lt;TClass&gt;

Interfaz principal para trabajar con caché en un contexto específico vinculado al tipo genérico:

```csharp
public interface ICacheHybrid<TClass>
{
    // Obtiene un valor de la caché o lo crea si no existe
    ValueTask<T> GetOrCreateAsync<T>(
        Func<Task<T>> factory, 
        dynamic?[] deps);
    
    // Obtiene un valor de la caché o lo crea si no existe con duración personalizada
    ValueTask<T> GetOrCreateAsync<T>(
        Func<Task<T>> factory, 
        dynamic?[] deps, 
        TimeSpan duration);
    
    // Elimina la caché específica para esta clase
    Task RemoveCache();
    
    // Elimina la caché basada en un valor de enumeración
    Task RemoveCache(Enum ands);
    
    // Elimina la caché basada en varios valores de enumeración
    Task RemoveCache(params Enum[] ands);
    
    // Elimina todas las entradas de caché
    Task RemoveCacheAll();
}

Uso de las abstracciones

Este paquete contiene solo las interfaces y no las implementaciones. Para utilizarlo, deberás:

1. Instalar este paquete en tu proyecto
2. Instalar o crear una implementación concreta (por ejemplo, Nosabit.CacheHybrid)
3. Usar inyección de dependencias para trabajar con las interfaces

Registro en el contenedor de IoC

// En Program.cs o Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // Registrar la implementación concreta de ICacheHybrid
    services.AddScoped(typeof(ICacheHybrid<>), typeof(YourCacheHybridImplementation<>));
}

Ejemplo de uso en un servicio

public class ProductoService
{
    private readonly ISqlDataAccess _db;
    private readonly ICacheHybrid<ProductoService> _cache;
    
    public ProductoService(ISqlDataAccess db, ICacheHybrid<ProductoService> cache)
    {
        _db = db;
        _cache = cache;
    }
    
    // Método que utiliza el caché para obtener datos
    public async Task<IEnumerable<Producto>> ObtenerTodosAsync()
    {
        // Intenta obtener de caché o crea la entrada si no existe
        return await _cache.GetOrCreateAsync(
            // Factory que se ejecuta cuando no hay datos en caché
            () => _db.QueryAsync<Producto>("sp_ObtenerProductos"),
            // Array de dependencias para crear la clave
            [nameof(ObtenerTodosAsync)]
        );
    }
    
    // Método que utiliza claves compuestas
    public async Task<Producto> ObtenerPorIdAsync(int id)
    {
        return await _cache.GetOrCreateAsync(
            () => _db.QueryFirstAsync<Producto>("sp_ObtenerProductoPorId", new { Id = id }),
            // Clave compuesta: nombre del método + id del producto
            [nameof(ObtenerPorIdAsync), id]
        );
    }
    
    // Método con caché de expiración personalizada
    public async Task<IEnumerable<Producto>> ObtenerDestacadosAsync()
    {
        return await _cache.GetOrCreateAsync(
            () => _db.QueryAsync<Producto>("sp_ObtenerProductosDestacados"),
            [nameof(ObtenerDestacadosAsync)],
            TimeSpan.FromMinutes(2) // Caché de corta duración
        );
    }
    
    // Método que invalida la caché tras una modificación
    public async Task<DBEntity> GuardarAsync(Producto producto)
    {
        var result = await _db.ExecuteAsync("sp_GuardarProducto", producto);
        
        // Invalidar todas las entradas de caché relacionadas con este servicio
        await _cache.RemoveCacheAll();
        
        return result;
    }
    
    // Método que invalida solo entradas específicas usando enum
    public enum ProductoCacheTipo
    {
        Detalle,
        Listado
    }
    
    public async Task<DBEntity> ActualizarStockAsync(int id, int cantidad)
    {
        var result = await _db.ExecuteAsync("sp_ActualizarStock", new { Id = id, Cantidad = cantidad });
        
        // Invalidar caché específica usando enum
        await _cache.RemoveCache(ProductoCacheTipo.Detalle);
        
        return result;
    }
}

Escenario de uso completo

El siguiente código ilustra un escenario completo de uso:

public interface ICategoriaMantenimientoService
{
    Task<DBEntity> CategoriaMantenimientoEliminar(string IdCategoriaMantenimientos);
    Task<DBEntity> CategoriaMantenimientoGuardar(CategoriaMantenimientoEntity entity, IEnumerable<TareasMantenimientoTp> Tareas);
    Task<IEnumerable<CategoriaMantenimientoEntity>> CategoriaMantenimientoObtener();
    Task<CategoriaMantenimientoEntity> CategoriaMantenimientoObtenerById(int IdCategoriaMantenimiento);
    Task<IEnumerable<SelectItemDto>> CategoriaMantenimientoObtenerCbo();
    Task<IEnumerable<TareasMantenimientoTp>> CategoriaMantenimientoObtenerTareasById(int IdCategoriaMantenimiento);
}

public class CategoriaMantenimientoService : ICategoriaMantenimientoService
{
    private readonly ISqlDataAccess _sql;
    private readonly ICacheHybrid<CategoriaMantenimientoService> _cache;
    
    public CategoriaMantenimientoService(ISqlDataAccess sql, ICacheHybrid<CategoriaMantenimientoService> cache)
    {
        _sql = sql;
        _cache = cache;
    }
    
    // Método que modifica datos e invalida toda la caché
    public async Task<DBEntity> CategoriaMantenimientoEliminar(string IdCategoriaMantenimientos)
    {
        var result = await _sql.ExecuteAsync("cat.CategoriaMantenimientoEliminar", new
        {
            IdCategoriaMantenimientos
        });
        
        // Eliminar toda la caché tras la modificación
        await _cache.RemoveCacheAll();
        
        return result;
    }
    
    // Método con caché para obtener listado completo
    public async Task<IEnumerable<CategoriaMantenimientoEntity>> CategoriaMantenimientoObtener()
    {
        // Esta sintaxis utiliza la característica de collection expressions de C# 12
        return await _cache.GetOrCreateAsync(
            () => _sql.QueryAsync<CategoriaMantenimientoEntity>("cat.CategoriaMantenimientoObtener"),
            [nameof(CategoriaMantenimientoObtener)]
        );
    }
    
    // Método con caché y clave compuesta para obtener elementos por ID
    public async Task<IEnumerable<TareasMantenimientoTp>> CategoriaMantenimientoObtenerTareasById(int IdCategoriaMantenimiento)
    {
        return await _cache.GetOrCreateAsync(
            () => _sql.QueryAsync<TareasMantenimientoTp>(
                "cat.CategoriaMantenimientoObtenerTareasById", 
                new { IdCategoriaMantenimiento }
            ),
            [nameof(CategoriaMantenimientoObtenerTareasById), IdCategoriaMantenimiento]
        );
    }
    
    // Método con combo box que también usa caché
    public async Task<IEnumerable<SelectItemDto>> CategoriaMantenimientoObtenerCbo()
    {
        return await _cache.GetOrCreateAsync(
            () => _sql.QueryAsync<SelectItemDto>("cat.CategoriaMantenimientoObtenerCbo"),
            [nameof(CategoriaMantenimientoObtenerCbo)]
        );
    }
}

Beneficios de utilizar estas abstracciones

• Separación de responsabilidades: Desacopla la lógica de caché de la lógica de negocio
• Facilidad para cambiar implementaciones: Permite reemplazar la estrategia de caché sin cambiar el código cliente
• Mejora del rendimiento: Reduce las llamadas a bases de datos u otros recursos costosos
• Invalidación inteligente: Proporciona control granular sobre qué datos se deben refrescar
• Testabilidad mejorada: Facilita la creación de mocks para pruebas unitarias
• Caché híbrido eficiente: Combina caché local y distribuido para un rendimiento óptimo
• Invalidación por tipo de contexto: Agrupación automática de caché por servicio (tipo genérico)
• Control de duración flexible: Permite personalizar la expiración por operación

Integración con otros paquetes Nosabit

Este paquete de abstracciones está diseñado para trabajar con otros paquetes de la familia Nosabit:

• Nosabit.Core: Proporciona tipos como DBEntity y SelectItemDto
• Nosabit.Adapters.Persistence.ICacheHybrid.Abstractions: Implementación concreta de estas abstracciones que usa Microsoft.Extensions.Caching.Hybrid

Requisitos

• .NET 6.0 o superior

Licencia

Este proyecto está licenciado bajo la Licencia MIT.