About HybridCache from database cache

[2501272126]

Now that .NET 9 supports HybridCache, are there plans to implement a module similar to Volo.Abp.Extensions.Caching.EntityFrameworkCore to adapt to databases such as MySQL, SQL Server, or Oracle? This would be aimed at addressing the challenges faced by medium and small-sized applications in a Windows environment when using Redis.

Machine translation, please bear with any inaccuracies.

[maliming]

hi

What code is needed in this new module? I mean you can easily use SQL Server to replace Distributed Redis Cache.

https://learn.microsoft.com/en-us/aspnet/core/performance/caching/distributed?view=aspnetcore-9.0#distributed-sql-server-cache

[2501272126]

Yes, you are right. mysql has Caching-MySQL and sqlserver has Microsoft.Extensions.Caching.SqlServer.
However, these solutions are independent of Entity Framework Core (EF Core), and integrating them with the ABP framework can be cumbersome.
To address this, I have implemented a simple module as follows:

public class CacheItem : BasicAggregateRoot<string> {
    private CacheItem() { }

    public CacheItem(string id, byte[] value, DateTimeOffset expiresAtTime, long? slidingExpirationInSeconds, DateTimeOffset? absoluteExpiration) : base(id) { 
        Value = value;
        ExpiresAtTime = expiresAtTime;
        SlidingExpirationInSeconds = slidingExpirationInSeconds;
        AbsoluteExpiration = absoluteExpiration;
    }

    public byte[] Value { get; set; }

    public DateTimeOffset ExpiresAtTime { get; set; }

    public long? SlidingExpirationInSeconds { get; set; }

    public DateTimeOffset? AbsoluteExpiration { get; set; }
}

[IgnoreMultiTenancy]
[ConnectionStringName(CacheDbProperties.ConnectionStringName)]
public class CacheDbContext(DbContextOptions<CacheDbContext> options) : AbpDbContext<CacheDbContext>(options), ICacheDbContext {
    public DbSet<CacheItem> Caches { get; set; }

    protected override void OnModelCreating(ModelBuilder builder) {
        base.OnModelCreating(builder);

        builder.ConfigureCache();
    }
}

public static class CacheDbContextModelCreatingExtensions {
    public static void ConfigureCache(this ModelBuilder builder) {
        Check.NotNull(builder, nameof(builder));

        if (builder.IsTenantOnlyDatabase()) {
            return;
        }

        builder.Entity<CacheItem>(b => {
            b.ToTable(CacheDbProperties.DbTablePrefix + "Caches", CacheDbProperties.DbSchema);

            b.HasKey(c => c.Id);
            b.Property(m => m.Id).HasMaxLength(449);
            b.Property(m => m.Value).IsRequired();
            b.Property(m=>m.ExpiresAtTime).IsRequired();

            b.HasIndex(m => m.Value);
        });
    }
}

[UnitOfWork]
public class EfCoreCache : IDistributedCache, IBufferDistributedCache {
	private readonly ICacheRepository _cacheRepository;

	public EfCoreCache(IOptions<CacheOptions> options, ICacheRepository cacheRepository) {
		_cacheRepository = cacheRepository;
	}

	//implement IDistributedCache, IBufferDistributedCache
	//use repository operation database
}

public class DeleteExpiredCacheWorker : AsyncPeriodicBackgroundWorkerBase {
    private readonly ISystemClock _systemClock;

    public DeleteExpiredCacheWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory, IOptions<CacheOptions> options) : base(timer, serviceScopeFactory) {
        Timer.Period = 600000 * 2; //20 minutes

        _systemClock = options.Value.SystemClock;
    }

    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) {
        var cacheRepository = workerContext.ServiceProvider.GetRequiredService<ICacheRepository>();
        await cacheRepository.DeleteExpiredCacheAsync(_systemClock.UtcNow);
    }
}

[DependsOn(typeof(AbpEntityFrameworkCoreModule))]
public class ExtensionsCachingPostgreSqlEntityFrameworkCoreModule : AbpModule {
    public override void ConfigureServices(ServiceConfigurationContext context) {
        context.Services.AddAbpDbContext<CacheDbContext>(options => {
            options.AddRepository<CacheItem, EfCoreCacheRepository>();
        });

        context.Services.Replace(ServiceDescriptor.Singleton<IDistributedCache, EfCoreCache>());
    }

    public override async Task OnApplicationInitializationAsync(ApplicationInitializationContext context) {
        await context.AddBackgroundWorkerAsync<DeleteExpiredCacheWorker>();
    }
}

This is the core implementation of the module, excluding configuration options. I am unsure if this approach introduces concurrency issues in multi-threaded environments or other problems.
I believe that if there were an official library to implement such functionality, it could help small applications break free from the constraints of Redis in the Windows environment.
Sometimes I need a persistent cache, but setting up Redis can be too troublesome.

[maliming]

Why do you want to use SqlServerDistributedCache with EF Core?

Microsoft has already implemented an efficient SQL server cache class, and we do not need to re-implement it using ABP EF Core.

https://github.com/dotnet/aspnetcore/blob/release/9.0/src/Caching/SqlServer/src/SqlServerCache.cs
https://github.com/dotnet/aspnetcore/blob/release/9.0/src/Caching/SqlServer/src/DatabaseOperations.cs

---

You can use the sql-cache tool to create the table in the provided connection string.

https://learn.microsoft.com/en-us/aspnet/core/performance/caching/distributed?view=aspnetcore-9.0#distributed-sql-server-cache

[2501272126]

I understand your point. SQL Server or MySQL was just an example; my application currently uses PostgreSQL, for ToJson support, I haven't found any Microsoft.Extensions.Caching implementations specifically for PostgreSQL, which led me to this idea.

Another reason is that my application requires repeated deployments, and the complex deployment conditions place high demands on the implementation personnel. It would be ideal if running the ABP.DbMigrator just once could resolve all issues.

Moreover, while caching is not critically important for my application, it is still necessary. This consideration also contributed to this idea.

This is just an idea, and I will attempt to implement it within my application. Thank you for your reply, have a pleasant day!

[2501272126]

Like the default background jobs and background worker implementation, They are lightweight and very useful.